1/* AUTOMATICALLY GENERATED, DO NOT MODIFY */
2
3/*
4 * schema-defined QAPI visitor functions
5 *
6 * Copyright IBM, Corp. 2011
7 *
8 * Authors:
9 * Anthony Liguori <aliguori@us.ibm.com>
10 *
11 * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
12 * See the COPYING.LIB file in the top-level directory.
13 *
14 */
15
16#include "qemu/osdep.h"
17#include "qemu-common.h"
18#include "qapi/error.h"
19#include "qapi-visit.h"
20
21void visit_type_ACPIOSTInfo_members(Visitor *v, ACPIOSTInfo *obj, Error **errp)
22{
23 Error *err = NULL;
24
25 if (visit_optional(v, "device", &obj->has_device)) {
26 visit_type_str(v, "device", &obj->device, &err);
27 if (err) {
28 goto out;
29 }
30 }
31 visit_type_str(v, "slot", &obj->slot, &err);
32 if (err) {
33 goto out;
34 }
35 visit_type_ACPISlotType(v, "slot-type", &obj->slot_type, &err);
36 if (err) {
37 goto out;
38 }
39 visit_type_int(v, "source", &obj->source, &err);
40 if (err) {
41 goto out;
42 }
43 visit_type_int(v, "status", &obj->status, &err);
44 if (err) {
45 goto out;
46 }
47
48out:
49 error_propagate(errp, err);
50}
51
52void visit_type_ACPIOSTInfo(Visitor *v, const char *name, ACPIOSTInfo **obj, Error **errp)
53{
54 Error *err = NULL;
55
56 visit_start_struct(v, name, (void **)obj, sizeof(ACPIOSTInfo), &err);
57 if (err) {
58 goto out;
59 }
60 if (!*obj) {
61 goto out_obj;
62 }
63 visit_type_ACPIOSTInfo_members(v, *obj, &err);
64 if (err) {
65 goto out_obj;
66 }
67 visit_check_struct(v, &err);
68out_obj:
69 visit_end_struct(v, (void **)obj);
70 if (err && visit_is_input(v)) {
71 qapi_free_ACPIOSTInfo(*obj);
72 *obj = NULL;
73 }
74out:
75 error_propagate(errp, err);
76}
77
78void visit_type_ACPIOSTInfoList(Visitor *v, const char *name, ACPIOSTInfoList **obj, Error **errp)
79{
80 Error *err = NULL;
81 ACPIOSTInfoList *tail;
82 size_t size = sizeof(**obj);
83
84 visit_start_list(v, name, (GenericList **)obj, size, &err);
85 if (err) {
86 goto out;
87 }
88
89 for (tail = *obj; tail;
90 tail = (ACPIOSTInfoList *)visit_next_list(v, (GenericList *)tail, size)) {
91 visit_type_ACPIOSTInfo(v, NULL, &tail->value, &err);
92 if (err) {
93 break;
94 }
95 }
96
97 if (!err) {
98 visit_check_list(v, &err);
99 }
100 visit_end_list(v, (void **)obj);
101 if (err && visit_is_input(v)) {
102 qapi_free_ACPIOSTInfoList(*obj);
103 *obj = NULL;
104 }
105out:
106 error_propagate(errp, err);
107}
108
109void visit_type_ACPISlotType(Visitor *v, const char *name, ACPISlotType *obj, Error **errp)
110{
111 int value = *obj;
112 visit_type_enum(v, name, &value, ACPISlotType_lookup, errp);
113 *obj = value;
114}
115
116void visit_type_Abort_members(Visitor *v, Abort *obj, Error **errp)
117{
118 Error *err = NULL;
119
120 error_propagate(errp, err);
121}
122
123void visit_type_Abort(Visitor *v, const char *name, Abort **obj, Error **errp)
124{
125 Error *err = NULL;
126
127 visit_start_struct(v, name, (void **)obj, sizeof(Abort), &err);
128 if (err) {
129 goto out;
130 }
131 if (!*obj) {
132 goto out_obj;
133 }
134 visit_type_Abort_members(v, *obj, &err);
135 if (err) {
136 goto out_obj;
137 }
138 visit_check_struct(v, &err);
139out_obj:
140 visit_end_struct(v, (void **)obj);
141 if (err && visit_is_input(v)) {
142 qapi_free_Abort(*obj);
143 *obj = NULL;
144 }
145out:
146 error_propagate(errp, err);
147}
148
149void visit_type_AcpiTableOptions_members(Visitor *v, AcpiTableOptions *obj, Error **errp)
150{
151 Error *err = NULL;
152
153 if (visit_optional(v, "sig", &obj->has_sig)) {
154 visit_type_str(v, "sig", &obj->sig, &err);
155 if (err) {
156 goto out;
157 }
158 }
159 if (visit_optional(v, "rev", &obj->has_rev)) {
160 visit_type_uint8(v, "rev", &obj->rev, &err);
161 if (err) {
162 goto out;
163 }
164 }
165 if (visit_optional(v, "oem_id", &obj->has_oem_id)) {
166 visit_type_str(v, "oem_id", &obj->oem_id, &err);
167 if (err) {
168 goto out;
169 }
170 }
171 if (visit_optional(v, "oem_table_id", &obj->has_oem_table_id)) {
172 visit_type_str(v, "oem_table_id", &obj->oem_table_id, &err);
173 if (err) {
174 goto out;
175 }
176 }
177 if (visit_optional(v, "oem_rev", &obj->has_oem_rev)) {
178 visit_type_uint32(v, "oem_rev", &obj->oem_rev, &err);
179 if (err) {
180 goto out;
181 }
182 }
183 if (visit_optional(v, "asl_compiler_id", &obj->has_asl_compiler_id)) {
184 visit_type_str(v, "asl_compiler_id", &obj->asl_compiler_id, &err);
185 if (err) {
186 goto out;
187 }
188 }
189 if (visit_optional(v, "asl_compiler_rev", &obj->has_asl_compiler_rev)) {
190 visit_type_uint32(v, "asl_compiler_rev", &obj->asl_compiler_rev, &err);
191 if (err) {
192 goto out;
193 }
194 }
195 if (visit_optional(v, "file", &obj->has_file)) {
196 visit_type_str(v, "file", &obj->file, &err);
197 if (err) {
198 goto out;
199 }
200 }
201 if (visit_optional(v, "data", &obj->has_data)) {
202 visit_type_str(v, "data", &obj->data, &err);
203 if (err) {
204 goto out;
205 }
206 }
207
208out:
209 error_propagate(errp, err);
210}
211
212void visit_type_AcpiTableOptions(Visitor *v, const char *name, AcpiTableOptions **obj, Error **errp)
213{
214 Error *err = NULL;
215
216 visit_start_struct(v, name, (void **)obj, sizeof(AcpiTableOptions), &err);
217 if (err) {
218 goto out;
219 }
220 if (!*obj) {
221 goto out_obj;
222 }
223 visit_type_AcpiTableOptions_members(v, *obj, &err);
224 if (err) {
225 goto out_obj;
226 }
227 visit_check_struct(v, &err);
228out_obj:
229 visit_end_struct(v, (void **)obj);
230 if (err && visit_is_input(v)) {
231 qapi_free_AcpiTableOptions(*obj);
232 *obj = NULL;
233 }
234out:
235 error_propagate(errp, err);
236}
237
238void visit_type_ActionCompletionMode(Visitor *v, const char *name, ActionCompletionMode *obj, Error **errp)
239{
240 int value = *obj;
241 visit_type_enum(v, name, &value, ActionCompletionMode_lookup, errp);
242 *obj = value;
243}
244
245void visit_type_AddfdInfo_members(Visitor *v, AddfdInfo *obj, Error **errp)
246{
247 Error *err = NULL;
248
249 visit_type_int(v, "fdset-id", &obj->fdset_id, &err);
250 if (err) {
251 goto out;
252 }
253 visit_type_int(v, "fd", &obj->fd, &err);
254 if (err) {
255 goto out;
256 }
257
258out:
259 error_propagate(errp, err);
260}
261
262void visit_type_AddfdInfo(Visitor *v, const char *name, AddfdInfo **obj, Error **errp)
263{
264 Error *err = NULL;
265
266 visit_start_struct(v, name, (void **)obj, sizeof(AddfdInfo), &err);
267 if (err) {
268 goto out;
269 }
270 if (!*obj) {
271 goto out_obj;
272 }
273 visit_type_AddfdInfo_members(v, *obj, &err);
274 if (err) {
275 goto out_obj;
276 }
277 visit_check_struct(v, &err);
278out_obj:
279 visit_end_struct(v, (void **)obj);
280 if (err && visit_is_input(v)) {
281 qapi_free_AddfdInfo(*obj);
282 *obj = NULL;
283 }
284out:
285 error_propagate(errp, err);
286}
287
288void visit_type_BalloonInfo_members(Visitor *v, BalloonInfo *obj, Error **errp)
289{
290 Error *err = NULL;
291
292 visit_type_int(v, "actual", &obj->actual, &err);
293 if (err) {
294 goto out;
295 }
296
297out:
298 error_propagate(errp, err);
299}
300
301void visit_type_BalloonInfo(Visitor *v, const char *name, BalloonInfo **obj, Error **errp)
302{
303 Error *err = NULL;
304
305 visit_start_struct(v, name, (void **)obj, sizeof(BalloonInfo), &err);
306 if (err) {
307 goto out;
308 }
309 if (!*obj) {
310 goto out_obj;
311 }
312 visit_type_BalloonInfo_members(v, *obj, &err);
313 if (err) {
314 goto out_obj;
315 }
316 visit_check_struct(v, &err);
317out_obj:
318 visit_end_struct(v, (void **)obj);
319 if (err && visit_is_input(v)) {
320 qapi_free_BalloonInfo(*obj);
321 *obj = NULL;
322 }
323out:
324 error_propagate(errp, err);
325}
326
327void visit_type_BiosAtaTranslation(Visitor *v, const char *name, BiosAtaTranslation *obj, Error **errp)
328{
329 int value = *obj;
330 visit_type_enum(v, name, &value, BiosAtaTranslation_lookup, errp);
331 *obj = value;
332}
333
334void visit_type_BlkdebugEvent(Visitor *v, const char *name, BlkdebugEvent *obj, Error **errp)
335{
336 int value = *obj;
337 visit_type_enum(v, name, &value, BlkdebugEvent_lookup, errp);
338 *obj = value;
339}
340
341void visit_type_BlkdebugInjectErrorOptions_members(Visitor *v, BlkdebugInjectErrorOptions *obj, Error **errp)
342{
343 Error *err = NULL;
344
345 visit_type_BlkdebugEvent(v, "event", &obj->event, &err);
346 if (err) {
347 goto out;
348 }
349 if (visit_optional(v, "state", &obj->has_state)) {
350 visit_type_int(v, "state", &obj->state, &err);
351 if (err) {
352 goto out;
353 }
354 }
355 if (visit_optional(v, "errno", &obj->has_q_errno)) {
356 visit_type_int(v, "errno", &obj->q_errno, &err);
357 if (err) {
358 goto out;
359 }
360 }
361 if (visit_optional(v, "sector", &obj->has_sector)) {
362 visit_type_int(v, "sector", &obj->sector, &err);
363 if (err) {
364 goto out;
365 }
366 }
367 if (visit_optional(v, "once", &obj->has_once)) {
368 visit_type_bool(v, "once", &obj->once, &err);
369 if (err) {
370 goto out;
371 }
372 }
373 if (visit_optional(v, "immediately", &obj->has_immediately)) {
374 visit_type_bool(v, "immediately", &obj->immediately, &err);
375 if (err) {
376 goto out;
377 }
378 }
379
380out:
381 error_propagate(errp, err);
382}
383
384void visit_type_BlkdebugInjectErrorOptions(Visitor *v, const char *name, BlkdebugInjectErrorOptions **obj, Error **errp)
385{
386 Error *err = NULL;
387
388 visit_start_struct(v, name, (void **)obj, sizeof(BlkdebugInjectErrorOptions), &err);
389 if (err) {
390 goto out;
391 }
392 if (!*obj) {
393 goto out_obj;
394 }
395 visit_type_BlkdebugInjectErrorOptions_members(v, *obj, &err);
396 if (err) {
397 goto out_obj;
398 }
399 visit_check_struct(v, &err);
400out_obj:
401 visit_end_struct(v, (void **)obj);
402 if (err && visit_is_input(v)) {
403 qapi_free_BlkdebugInjectErrorOptions(*obj);
404 *obj = NULL;
405 }
406out:
407 error_propagate(errp, err);
408}
409
410void visit_type_BlkdebugInjectErrorOptionsList(Visitor *v, const char *name, BlkdebugInjectErrorOptionsList **obj, Error **errp)
411{
412 Error *err = NULL;
413 BlkdebugInjectErrorOptionsList *tail;
414 size_t size = sizeof(**obj);
415
416 visit_start_list(v, name, (GenericList **)obj, size, &err);
417 if (err) {
418 goto out;
419 }
420
421 for (tail = *obj; tail;
422 tail = (BlkdebugInjectErrorOptionsList *)visit_next_list(v, (GenericList *)tail, size)) {
423 visit_type_BlkdebugInjectErrorOptions(v, NULL, &tail->value, &err);
424 if (err) {
425 break;
426 }
427 }
428
429 if (!err) {
430 visit_check_list(v, &err);
431 }
432 visit_end_list(v, (void **)obj);
433 if (err && visit_is_input(v)) {
434 qapi_free_BlkdebugInjectErrorOptionsList(*obj);
435 *obj = NULL;
436 }
437out:
438 error_propagate(errp, err);
439}
440
441void visit_type_BlkdebugSetStateOptions_members(Visitor *v, BlkdebugSetStateOptions *obj, Error **errp)
442{
443 Error *err = NULL;
444
445 visit_type_BlkdebugEvent(v, "event", &obj->event, &err);
446 if (err) {
447 goto out;
448 }
449 if (visit_optional(v, "state", &obj->has_state)) {
450 visit_type_int(v, "state", &obj->state, &err);
451 if (err) {
452 goto out;
453 }
454 }
455 visit_type_int(v, "new_state", &obj->new_state, &err);
456 if (err) {
457 goto out;
458 }
459
460out:
461 error_propagate(errp, err);
462}
463
464void visit_type_BlkdebugSetStateOptions(Visitor *v, const char *name, BlkdebugSetStateOptions **obj, Error **errp)
465{
466 Error *err = NULL;
467
468 visit_start_struct(v, name, (void **)obj, sizeof(BlkdebugSetStateOptions), &err);
469 if (err) {
470 goto out;
471 }
472 if (!*obj) {
473 goto out_obj;
474 }
475 visit_type_BlkdebugSetStateOptions_members(v, *obj, &err);
476 if (err) {
477 goto out_obj;
478 }
479 visit_check_struct(v, &err);
480out_obj:
481 visit_end_struct(v, (void **)obj);
482 if (err && visit_is_input(v)) {
483 qapi_free_BlkdebugSetStateOptions(*obj);
484 *obj = NULL;
485 }
486out:
487 error_propagate(errp, err);
488}
489
490void visit_type_BlkdebugSetStateOptionsList(Visitor *v, const char *name, BlkdebugSetStateOptionsList **obj, Error **errp)
491{
492 Error *err = NULL;
493 BlkdebugSetStateOptionsList *tail;
494 size_t size = sizeof(**obj);
495
496 visit_start_list(v, name, (GenericList **)obj, size, &err);
497 if (err) {
498 goto out;
499 }
500
501 for (tail = *obj; tail;
502 tail = (BlkdebugSetStateOptionsList *)visit_next_list(v, (GenericList *)tail, size)) {
503 visit_type_BlkdebugSetStateOptions(v, NULL, &tail->value, &err);
504 if (err) {
505 break;
506 }
507 }
508
509 if (!err) {
510 visit_check_list(v, &err);
511 }
512 visit_end_list(v, (void **)obj);
513 if (err && visit_is_input(v)) {
514 qapi_free_BlkdebugSetStateOptionsList(*obj);
515 *obj = NULL;
516 }
517out:
518 error_propagate(errp, err);
519}
520
521void visit_type_BlockDeviceInfo_members(Visitor *v, BlockDeviceInfo *obj, Error **errp)
522{
523 Error *err = NULL;
524
525 visit_type_str(v, "file", &obj->file, &err);
526 if (err) {
527 goto out;
528 }
529 if (visit_optional(v, "node-name", &obj->has_node_name)) {
530 visit_type_str(v, "node-name", &obj->node_name, &err);
531 if (err) {
532 goto out;
533 }
534 }
535 visit_type_bool(v, "ro", &obj->ro, &err);
536 if (err) {
537 goto out;
538 }
539 visit_type_str(v, "drv", &obj->drv, &err);
540 if (err) {
541 goto out;
542 }
543 if (visit_optional(v, "backing_file", &obj->has_backing_file)) {
544 visit_type_str(v, "backing_file", &obj->backing_file, &err);
545 if (err) {
546 goto out;
547 }
548 }
549 visit_type_int(v, "backing_file_depth", &obj->backing_file_depth, &err);
550 if (err) {
551 goto out;
552 }
553 visit_type_bool(v, "encrypted", &obj->encrypted, &err);
554 if (err) {
555 goto out;
556 }
557 visit_type_bool(v, "encryption_key_missing", &obj->encryption_key_missing, &err);
558 if (err) {
559 goto out;
560 }
561 visit_type_BlockdevDetectZeroesOptions(v, "detect_zeroes", &obj->detect_zeroes, &err);
562 if (err) {
563 goto out;
564 }
565 visit_type_int(v, "bps", &obj->bps, &err);
566 if (err) {
567 goto out;
568 }
569 visit_type_int(v, "bps_rd", &obj->bps_rd, &err);
570 if (err) {
571 goto out;
572 }
573 visit_type_int(v, "bps_wr", &obj->bps_wr, &err);
574 if (err) {
575 goto out;
576 }
577 visit_type_int(v, "iops", &obj->iops, &err);
578 if (err) {
579 goto out;
580 }
581 visit_type_int(v, "iops_rd", &obj->iops_rd, &err);
582 if (err) {
583 goto out;
584 }
585 visit_type_int(v, "iops_wr", &obj->iops_wr, &err);
586 if (err) {
587 goto out;
588 }
589 visit_type_ImageInfo(v, "image", &obj->image, &err);
590 if (err) {
591 goto out;
592 }
593 if (visit_optional(v, "bps_max", &obj->has_bps_max)) {
594 visit_type_int(v, "bps_max", &obj->bps_max, &err);
595 if (err) {
596 goto out;
597 }
598 }
599 if (visit_optional(v, "bps_rd_max", &obj->has_bps_rd_max)) {
600 visit_type_int(v, "bps_rd_max", &obj->bps_rd_max, &err);
601 if (err) {
602 goto out;
603 }
604 }
605 if (visit_optional(v, "bps_wr_max", &obj->has_bps_wr_max)) {
606 visit_type_int(v, "bps_wr_max", &obj->bps_wr_max, &err);
607 if (err) {
608 goto out;
609 }
610 }
611 if (visit_optional(v, "iops_max", &obj->has_iops_max)) {
612 visit_type_int(v, "iops_max", &obj->iops_max, &err);
613 if (err) {
614 goto out;
615 }
616 }
617 if (visit_optional(v, "iops_rd_max", &obj->has_iops_rd_max)) {
618 visit_type_int(v, "iops_rd_max", &obj->iops_rd_max, &err);
619 if (err) {
620 goto out;
621 }
622 }
623 if (visit_optional(v, "iops_wr_max", &obj->has_iops_wr_max)) {
624 visit_type_int(v, "iops_wr_max", &obj->iops_wr_max, &err);
625 if (err) {
626 goto out;
627 }
628 }
629 if (visit_optional(v, "bps_max_length", &obj->has_bps_max_length)) {
630 visit_type_int(v, "bps_max_length", &obj->bps_max_length, &err);
631 if (err) {
632 goto out;
633 }
634 }
635 if (visit_optional(v, "bps_rd_max_length", &obj->has_bps_rd_max_length)) {
636 visit_type_int(v, "bps_rd_max_length", &obj->bps_rd_max_length, &err);
637 if (err) {
638 goto out;
639 }
640 }
641 if (visit_optional(v, "bps_wr_max_length", &obj->has_bps_wr_max_length)) {
642 visit_type_int(v, "bps_wr_max_length", &obj->bps_wr_max_length, &err);
643 if (err) {
644 goto out;
645 }
646 }
647 if (visit_optional(v, "iops_max_length", &obj->has_iops_max_length)) {
648 visit_type_int(v, "iops_max_length", &obj->iops_max_length, &err);
649 if (err) {
650 goto out;
651 }
652 }
653 if (visit_optional(v, "iops_rd_max_length", &obj->has_iops_rd_max_length)) {
654 visit_type_int(v, "iops_rd_max_length", &obj->iops_rd_max_length, &err);
655 if (err) {
656 goto out;
657 }
658 }
659 if (visit_optional(v, "iops_wr_max_length", &obj->has_iops_wr_max_length)) {
660 visit_type_int(v, "iops_wr_max_length", &obj->iops_wr_max_length, &err);
661 if (err) {
662 goto out;
663 }
664 }
665 if (visit_optional(v, "iops_size", &obj->has_iops_size)) {
666 visit_type_int(v, "iops_size", &obj->iops_size, &err);
667 if (err) {
668 goto out;
669 }
670 }
671 if (visit_optional(v, "group", &obj->has_group)) {
672 visit_type_str(v, "group", &obj->group, &err);
673 if (err) {
674 goto out;
675 }
676 }
677 visit_type_BlockdevCacheInfo(v, "cache", &obj->cache, &err);
678 if (err) {
679 goto out;
680 }
681 visit_type_int(v, "write_threshold", &obj->write_threshold, &err);
682 if (err) {
683 goto out;
684 }
685
686out:
687 error_propagate(errp, err);
688}
689
690void visit_type_BlockDeviceInfo(Visitor *v, const char *name, BlockDeviceInfo **obj, Error **errp)
691{
692 Error *err = NULL;
693
694 visit_start_struct(v, name, (void **)obj, sizeof(BlockDeviceInfo), &err);
695 if (err) {
696 goto out;
697 }
698 if (!*obj) {
699 goto out_obj;
700 }
701 visit_type_BlockDeviceInfo_members(v, *obj, &err);
702 if (err) {
703 goto out_obj;
704 }
705 visit_check_struct(v, &err);
706out_obj:
707 visit_end_struct(v, (void **)obj);
708 if (err && visit_is_input(v)) {
709 qapi_free_BlockDeviceInfo(*obj);
710 *obj = NULL;
711 }
712out:
713 error_propagate(errp, err);
714}
715
716void visit_type_BlockDeviceInfoList(Visitor *v, const char *name, BlockDeviceInfoList **obj, Error **errp)
717{
718 Error *err = NULL;
719 BlockDeviceInfoList *tail;
720 size_t size = sizeof(**obj);
721
722 visit_start_list(v, name, (GenericList **)obj, size, &err);
723 if (err) {
724 goto out;
725 }
726
727 for (tail = *obj; tail;
728 tail = (BlockDeviceInfoList *)visit_next_list(v, (GenericList *)tail, size)) {
729 visit_type_BlockDeviceInfo(v, NULL, &tail->value, &err);
730 if (err) {
731 break;
732 }
733 }
734
735 if (!err) {
736 visit_check_list(v, &err);
737 }
738 visit_end_list(v, (void **)obj);
739 if (err && visit_is_input(v)) {
740 qapi_free_BlockDeviceInfoList(*obj);
741 *obj = NULL;
742 }
743out:
744 error_propagate(errp, err);
745}
746
747void visit_type_BlockDeviceIoStatus(Visitor *v, const char *name, BlockDeviceIoStatus *obj, Error **errp)
748{
749 int value = *obj;
750 visit_type_enum(v, name, &value, BlockDeviceIoStatus_lookup, errp);
751 *obj = value;
752}
753
754void visit_type_BlockDeviceMapEntry_members(Visitor *v, BlockDeviceMapEntry *obj, Error **errp)
755{
756 Error *err = NULL;
757
758 visit_type_int(v, "start", &obj->start, &err);
759 if (err) {
760 goto out;
761 }
762 visit_type_int(v, "length", &obj->length, &err);
763 if (err) {
764 goto out;
765 }
766 visit_type_int(v, "depth", &obj->depth, &err);
767 if (err) {
768 goto out;
769 }
770 visit_type_bool(v, "zero", &obj->zero, &err);
771 if (err) {
772 goto out;
773 }
774 visit_type_bool(v, "data", &obj->data, &err);
775 if (err) {
776 goto out;
777 }
778 if (visit_optional(v, "offset", &obj->has_offset)) {
779 visit_type_int(v, "offset", &obj->offset, &err);
780 if (err) {
781 goto out;
782 }
783 }
784
785out:
786 error_propagate(errp, err);
787}
788
789void visit_type_BlockDeviceMapEntry(Visitor *v, const char *name, BlockDeviceMapEntry **obj, Error **errp)
790{
791 Error *err = NULL;
792
793 visit_start_struct(v, name, (void **)obj, sizeof(BlockDeviceMapEntry), &err);
794 if (err) {
795 goto out;
796 }
797 if (!*obj) {
798 goto out_obj;
799 }
800 visit_type_BlockDeviceMapEntry_members(v, *obj, &err);
801 if (err) {
802 goto out_obj;
803 }
804 visit_check_struct(v, &err);
805out_obj:
806 visit_end_struct(v, (void **)obj);
807 if (err && visit_is_input(v)) {
808 qapi_free_BlockDeviceMapEntry(*obj);
809 *obj = NULL;
810 }
811out:
812 error_propagate(errp, err);
813}
814
815void visit_type_BlockDeviceStats_members(Visitor *v, BlockDeviceStats *obj, Error **errp)
816{
817 Error *err = NULL;
818
819 visit_type_int(v, "rd_bytes", &obj->rd_bytes, &err);
820 if (err) {
821 goto out;
822 }
823 visit_type_int(v, "wr_bytes", &obj->wr_bytes, &err);
824 if (err) {
825 goto out;
826 }
827 visit_type_int(v, "rd_operations", &obj->rd_operations, &err);
828 if (err) {
829 goto out;
830 }
831 visit_type_int(v, "wr_operations", &obj->wr_operations, &err);
832 if (err) {
833 goto out;
834 }
835 visit_type_int(v, "flush_operations", &obj->flush_operations, &err);
836 if (err) {
837 goto out;
838 }
839 visit_type_int(v, "flush_total_time_ns", &obj->flush_total_time_ns, &err);
840 if (err) {
841 goto out;
842 }
843 visit_type_int(v, "wr_total_time_ns", &obj->wr_total_time_ns, &err);
844 if (err) {
845 goto out;
846 }
847 visit_type_int(v, "rd_total_time_ns", &obj->rd_total_time_ns, &err);
848 if (err) {
849 goto out;
850 }
851 visit_type_int(v, "wr_highest_offset", &obj->wr_highest_offset, &err);
852 if (err) {
853 goto out;
854 }
855 visit_type_int(v, "rd_merged", &obj->rd_merged, &err);
856 if (err) {
857 goto out;
858 }
859 visit_type_int(v, "wr_merged", &obj->wr_merged, &err);
860 if (err) {
861 goto out;
862 }
863 if (visit_optional(v, "idle_time_ns", &obj->has_idle_time_ns)) {
864 visit_type_int(v, "idle_time_ns", &obj->idle_time_ns, &err);
865 if (err) {
866 goto out;
867 }
868 }
869 visit_type_int(v, "failed_rd_operations", &obj->failed_rd_operations, &err);
870 if (err) {
871 goto out;
872 }
873 visit_type_int(v, "failed_wr_operations", &obj->failed_wr_operations, &err);
874 if (err) {
875 goto out;
876 }
877 visit_type_int(v, "failed_flush_operations", &obj->failed_flush_operations, &err);
878 if (err) {
879 goto out;
880 }
881 visit_type_int(v, "invalid_rd_operations", &obj->invalid_rd_operations, &err);
882 if (err) {
883 goto out;
884 }
885 visit_type_int(v, "invalid_wr_operations", &obj->invalid_wr_operations, &err);
886 if (err) {
887 goto out;
888 }
889 visit_type_int(v, "invalid_flush_operations", &obj->invalid_flush_operations, &err);
890 if (err) {
891 goto out;
892 }
893 visit_type_bool(v, "account_invalid", &obj->account_invalid, &err);
894 if (err) {
895 goto out;
896 }
897 visit_type_bool(v, "account_failed", &obj->account_failed, &err);
898 if (err) {
899 goto out;
900 }
901 visit_type_BlockDeviceTimedStatsList(v, "timed_stats", &obj->timed_stats, &err);
902 if (err) {
903 goto out;
904 }
905
906out:
907 error_propagate(errp, err);
908}
909
910void visit_type_BlockDeviceStats(Visitor *v, const char *name, BlockDeviceStats **obj, Error **errp)
911{
912 Error *err = NULL;
913
914 visit_start_struct(v, name, (void **)obj, sizeof(BlockDeviceStats), &err);
915 if (err) {
916 goto out;
917 }
918 if (!*obj) {
919 goto out_obj;
920 }
921 visit_type_BlockDeviceStats_members(v, *obj, &err);
922 if (err) {
923 goto out_obj;
924 }
925 visit_check_struct(v, &err);
926out_obj:
927 visit_end_struct(v, (void **)obj);
928 if (err && visit_is_input(v)) {
929 qapi_free_BlockDeviceStats(*obj);
930 *obj = NULL;
931 }
932out:
933 error_propagate(errp, err);
934}
935
936void visit_type_BlockDeviceTimedStats_members(Visitor *v, BlockDeviceTimedStats *obj, Error **errp)
937{
938 Error *err = NULL;
939
940 visit_type_int(v, "interval_length", &obj->interval_length, &err);
941 if (err) {
942 goto out;
943 }
944 visit_type_int(v, "min_rd_latency_ns", &obj->min_rd_latency_ns, &err);
945 if (err) {
946 goto out;
947 }
948 visit_type_int(v, "max_rd_latency_ns", &obj->max_rd_latency_ns, &err);
949 if (err) {
950 goto out;
951 }
952 visit_type_int(v, "avg_rd_latency_ns", &obj->avg_rd_latency_ns, &err);
953 if (err) {
954 goto out;
955 }
956 visit_type_int(v, "min_wr_latency_ns", &obj->min_wr_latency_ns, &err);
957 if (err) {
958 goto out;
959 }
960 visit_type_int(v, "max_wr_latency_ns", &obj->max_wr_latency_ns, &err);
961 if (err) {
962 goto out;
963 }
964 visit_type_int(v, "avg_wr_latency_ns", &obj->avg_wr_latency_ns, &err);
965 if (err) {
966 goto out;
967 }
968 visit_type_int(v, "min_flush_latency_ns", &obj->min_flush_latency_ns, &err);
969 if (err) {
970 goto out;
971 }
972 visit_type_int(v, "max_flush_latency_ns", &obj->max_flush_latency_ns, &err);
973 if (err) {
974 goto out;
975 }
976 visit_type_int(v, "avg_flush_latency_ns", &obj->avg_flush_latency_ns, &err);
977 if (err) {
978 goto out;
979 }
980 visit_type_number(v, "avg_rd_queue_depth", &obj->avg_rd_queue_depth, &err);
981 if (err) {
982 goto out;
983 }
984 visit_type_number(v, "avg_wr_queue_depth", &obj->avg_wr_queue_depth, &err);
985 if (err) {
986 goto out;
987 }
988
989out:
990 error_propagate(errp, err);
991}
992
993void visit_type_BlockDeviceTimedStats(Visitor *v, const char *name, BlockDeviceTimedStats **obj, Error **errp)
994{
995 Error *err = NULL;
996
997 visit_start_struct(v, name, (void **)obj, sizeof(BlockDeviceTimedStats), &err);
998 if (err) {
999 goto out;
1000 }
1001 if (!*obj) {
1002 goto out_obj;
1003 }
1004 visit_type_BlockDeviceTimedStats_members(v, *obj, &err);
1005 if (err) {
1006 goto out_obj;
1007 }
1008 visit_check_struct(v, &err);
1009out_obj:
1010 visit_end_struct(v, (void **)obj);
1011 if (err && visit_is_input(v)) {
1012 qapi_free_BlockDeviceTimedStats(*obj);
1013 *obj = NULL;
1014 }
1015out:
1016 error_propagate(errp, err);
1017}
1018
1019void visit_type_BlockDeviceTimedStatsList(Visitor *v, const char *name, BlockDeviceTimedStatsList **obj, Error **errp)
1020{
1021 Error *err = NULL;
1022 BlockDeviceTimedStatsList *tail;
1023 size_t size = sizeof(**obj);
1024
1025 visit_start_list(v, name, (GenericList **)obj, size, &err);
1026 if (err) {
1027 goto out;
1028 }
1029
1030 for (tail = *obj; tail;
1031 tail = (BlockDeviceTimedStatsList *)visit_next_list(v, (GenericList *)tail, size)) {
1032 visit_type_BlockDeviceTimedStats(v, NULL, &tail->value, &err);
1033 if (err) {
1034 break;
1035 }
1036 }
1037
1038 if (!err) {
1039 visit_check_list(v, &err);
1040 }
1041 visit_end_list(v, (void **)obj);
1042 if (err && visit_is_input(v)) {
1043 qapi_free_BlockDeviceTimedStatsList(*obj);
1044 *obj = NULL;
1045 }
1046out:
1047 error_propagate(errp, err);
1048}
1049
1050void visit_type_BlockDirtyBitmap_members(Visitor *v, BlockDirtyBitmap *obj, Error **errp)
1051{
1052 Error *err = NULL;
1053
1054 visit_type_str(v, "node", &obj->node, &err);
1055 if (err) {
1056 goto out;
1057 }
1058 visit_type_str(v, "name", &obj->name, &err);
1059 if (err) {
1060 goto out;
1061 }
1062
1063out:
1064 error_propagate(errp, err);
1065}
1066
1067void visit_type_BlockDirtyBitmap(Visitor *v, const char *name, BlockDirtyBitmap **obj, Error **errp)
1068{
1069 Error *err = NULL;
1070
1071 visit_start_struct(v, name, (void **)obj, sizeof(BlockDirtyBitmap), &err);
1072 if (err) {
1073 goto out;
1074 }
1075 if (!*obj) {
1076 goto out_obj;
1077 }
1078 visit_type_BlockDirtyBitmap_members(v, *obj, &err);
1079 if (err) {
1080 goto out_obj;
1081 }
1082 visit_check_struct(v, &err);
1083out_obj:
1084 visit_end_struct(v, (void **)obj);
1085 if (err && visit_is_input(v)) {
1086 qapi_free_BlockDirtyBitmap(*obj);
1087 *obj = NULL;
1088 }
1089out:
1090 error_propagate(errp, err);
1091}
1092
1093void visit_type_BlockDirtyBitmapAdd_members(Visitor *v, BlockDirtyBitmapAdd *obj, Error **errp)
1094{
1095 Error *err = NULL;
1096
1097 visit_type_str(v, "node", &obj->node, &err);
1098 if (err) {
1099 goto out;
1100 }
1101 visit_type_str(v, "name", &obj->name, &err);
1102 if (err) {
1103 goto out;
1104 }
1105 if (visit_optional(v, "granularity", &obj->has_granularity)) {
1106 visit_type_uint32(v, "granularity", &obj->granularity, &err);
1107 if (err) {
1108 goto out;
1109 }
1110 }
1111 if (visit_optional(v, "persistent", &obj->has_persistent)) {
1112 visit_type_bool(v, "persistent", &obj->persistent, &err);
1113 if (err) {
1114 goto out;
1115 }
1116 }
1117 if (visit_optional(v, "autoload", &obj->has_autoload)) {
1118 visit_type_bool(v, "autoload", &obj->autoload, &err);
1119 if (err) {
1120 goto out;
1121 }
1122 }
1123
1124out:
1125 error_propagate(errp, err);
1126}
1127
1128void visit_type_BlockDirtyBitmapAdd(Visitor *v, const char *name, BlockDirtyBitmapAdd **obj, Error **errp)
1129{
1130 Error *err = NULL;
1131
1132 visit_start_struct(v, name, (void **)obj, sizeof(BlockDirtyBitmapAdd), &err);
1133 if (err) {
1134 goto out;
1135 }
1136 if (!*obj) {
1137 goto out_obj;
1138 }
1139 visit_type_BlockDirtyBitmapAdd_members(v, *obj, &err);
1140 if (err) {
1141 goto out_obj;
1142 }
1143 visit_check_struct(v, &err);
1144out_obj:
1145 visit_end_struct(v, (void **)obj);
1146 if (err && visit_is_input(v)) {
1147 qapi_free_BlockDirtyBitmapAdd(*obj);
1148 *obj = NULL;
1149 }
1150out:
1151 error_propagate(errp, err);
1152}
1153
1154void visit_type_BlockDirtyBitmapSha256_members(Visitor *v, BlockDirtyBitmapSha256 *obj, Error **errp)
1155{
1156 Error *err = NULL;
1157
1158 visit_type_str(v, "sha256", &obj->sha256, &err);
1159 if (err) {
1160 goto out;
1161 }
1162
1163out:
1164 error_propagate(errp, err);
1165}
1166
1167void visit_type_BlockDirtyBitmapSha256(Visitor *v, const char *name, BlockDirtyBitmapSha256 **obj, Error **errp)
1168{
1169 Error *err = NULL;
1170
1171 visit_start_struct(v, name, (void **)obj, sizeof(BlockDirtyBitmapSha256), &err);
1172 if (err) {
1173 goto out;
1174 }
1175 if (!*obj) {
1176 goto out_obj;
1177 }
1178 visit_type_BlockDirtyBitmapSha256_members(v, *obj, &err);
1179 if (err) {
1180 goto out_obj;
1181 }
1182 visit_check_struct(v, &err);
1183out_obj:
1184 visit_end_struct(v, (void **)obj);
1185 if (err && visit_is_input(v)) {
1186 qapi_free_BlockDirtyBitmapSha256(*obj);
1187 *obj = NULL;
1188 }
1189out:
1190 error_propagate(errp, err);
1191}
1192
1193void visit_type_BlockDirtyInfo_members(Visitor *v, BlockDirtyInfo *obj, Error **errp)
1194{
1195 Error *err = NULL;
1196
1197 if (visit_optional(v, "name", &obj->has_name)) {
1198 visit_type_str(v, "name", &obj->name, &err);
1199 if (err) {
1200 goto out;
1201 }
1202 }
1203 visit_type_int(v, "count", &obj->count, &err);
1204 if (err) {
1205 goto out;
1206 }
1207 visit_type_uint32(v, "granularity", &obj->granularity, &err);
1208 if (err) {
1209 goto out;
1210 }
1211 visit_type_DirtyBitmapStatus(v, "status", &obj->status, &err);
1212 if (err) {
1213 goto out;
1214 }
1215
1216out:
1217 error_propagate(errp, err);
1218}
1219
1220void visit_type_BlockDirtyInfo(Visitor *v, const char *name, BlockDirtyInfo **obj, Error **errp)
1221{
1222 Error *err = NULL;
1223
1224 visit_start_struct(v, name, (void **)obj, sizeof(BlockDirtyInfo), &err);
1225 if (err) {
1226 goto out;
1227 }
1228 if (!*obj) {
1229 goto out_obj;
1230 }
1231 visit_type_BlockDirtyInfo_members(v, *obj, &err);
1232 if (err) {
1233 goto out_obj;
1234 }
1235 visit_check_struct(v, &err);
1236out_obj:
1237 visit_end_struct(v, (void **)obj);
1238 if (err && visit_is_input(v)) {
1239 qapi_free_BlockDirtyInfo(*obj);
1240 *obj = NULL;
1241 }
1242out:
1243 error_propagate(errp, err);
1244}
1245
1246void visit_type_BlockDirtyInfoList(Visitor *v, const char *name, BlockDirtyInfoList **obj, Error **errp)
1247{
1248 Error *err = NULL;
1249 BlockDirtyInfoList *tail;
1250 size_t size = sizeof(**obj);
1251
1252 visit_start_list(v, name, (GenericList **)obj, size, &err);
1253 if (err) {
1254 goto out;
1255 }
1256
1257 for (tail = *obj; tail;
1258 tail = (BlockDirtyInfoList *)visit_next_list(v, (GenericList *)tail, size)) {
1259 visit_type_BlockDirtyInfo(v, NULL, &tail->value, &err);
1260 if (err) {
1261 break;
1262 }
1263 }
1264
1265 if (!err) {
1266 visit_check_list(v, &err);
1267 }
1268 visit_end_list(v, (void **)obj);
1269 if (err && visit_is_input(v)) {
1270 qapi_free_BlockDirtyInfoList(*obj);
1271 *obj = NULL;
1272 }
1273out:
1274 error_propagate(errp, err);
1275}
1276
1277void visit_type_BlockErrorAction(Visitor *v, const char *name, BlockErrorAction *obj, Error **errp)
1278{
1279 int value = *obj;
1280 visit_type_enum(v, name, &value, BlockErrorAction_lookup, errp);
1281 *obj = value;
1282}
1283
1284void visit_type_BlockIOThrottle_members(Visitor *v, BlockIOThrottle *obj, Error **errp)
1285{
1286 Error *err = NULL;
1287
1288 if (visit_optional(v, "device", &obj->has_device)) {
1289 visit_type_str(v, "device", &obj->device, &err);
1290 if (err) {
1291 goto out;
1292 }
1293 }
1294 if (visit_optional(v, "id", &obj->has_id)) {
1295 visit_type_str(v, "id", &obj->id, &err);
1296 if (err) {
1297 goto out;
1298 }
1299 }
1300 visit_type_int(v, "bps", &obj->bps, &err);
1301 if (err) {
1302 goto out;
1303 }
1304 visit_type_int(v, "bps_rd", &obj->bps_rd, &err);
1305 if (err) {
1306 goto out;
1307 }
1308 visit_type_int(v, "bps_wr", &obj->bps_wr, &err);
1309 if (err) {
1310 goto out;
1311 }
1312 visit_type_int(v, "iops", &obj->iops, &err);
1313 if (err) {
1314 goto out;
1315 }
1316 visit_type_int(v, "iops_rd", &obj->iops_rd, &err);
1317 if (err) {
1318 goto out;
1319 }
1320 visit_type_int(v, "iops_wr", &obj->iops_wr, &err);
1321 if (err) {
1322 goto out;
1323 }
1324 if (visit_optional(v, "bps_max", &obj->has_bps_max)) {
1325 visit_type_int(v, "bps_max", &obj->bps_max, &err);
1326 if (err) {
1327 goto out;
1328 }
1329 }
1330 if (visit_optional(v, "bps_rd_max", &obj->has_bps_rd_max)) {
1331 visit_type_int(v, "bps_rd_max", &obj->bps_rd_max, &err);
1332 if (err) {
1333 goto out;
1334 }
1335 }
1336 if (visit_optional(v, "bps_wr_max", &obj->has_bps_wr_max)) {
1337 visit_type_int(v, "bps_wr_max", &obj->bps_wr_max, &err);
1338 if (err) {
1339 goto out;
1340 }
1341 }
1342 if (visit_optional(v, "iops_max", &obj->has_iops_max)) {
1343 visit_type_int(v, "iops_max", &obj->iops_max, &err);
1344 if (err) {
1345 goto out;
1346 }
1347 }
1348 if (visit_optional(v, "iops_rd_max", &obj->has_iops_rd_max)) {
1349 visit_type_int(v, "iops_rd_max", &obj->iops_rd_max, &err);
1350 if (err) {
1351 goto out;
1352 }
1353 }
1354 if (visit_optional(v, "iops_wr_max", &obj->has_iops_wr_max)) {
1355 visit_type_int(v, "iops_wr_max", &obj->iops_wr_max, &err);
1356 if (err) {
1357 goto out;
1358 }
1359 }
1360 if (visit_optional(v, "bps_max_length", &obj->has_bps_max_length)) {
1361 visit_type_int(v, "bps_max_length", &obj->bps_max_length, &err);
1362 if (err) {
1363 goto out;
1364 }
1365 }
1366 if (visit_optional(v, "bps_rd_max_length", &obj->has_bps_rd_max_length)) {
1367 visit_type_int(v, "bps_rd_max_length", &obj->bps_rd_max_length, &err);
1368 if (err) {
1369 goto out;
1370 }
1371 }
1372 if (visit_optional(v, "bps_wr_max_length", &obj->has_bps_wr_max_length)) {
1373 visit_type_int(v, "bps_wr_max_length", &obj->bps_wr_max_length, &err);
1374 if (err) {
1375 goto out;
1376 }
1377 }
1378 if (visit_optional(v, "iops_max_length", &obj->has_iops_max_length)) {
1379 visit_type_int(v, "iops_max_length", &obj->iops_max_length, &err);
1380 if (err) {
1381 goto out;
1382 }
1383 }
1384 if (visit_optional(v, "iops_rd_max_length", &obj->has_iops_rd_max_length)) {
1385 visit_type_int(v, "iops_rd_max_length", &obj->iops_rd_max_length, &err);
1386 if (err) {
1387 goto out;
1388 }
1389 }
1390 if (visit_optional(v, "iops_wr_max_length", &obj->has_iops_wr_max_length)) {
1391 visit_type_int(v, "iops_wr_max_length", &obj->iops_wr_max_length, &err);
1392 if (err) {
1393 goto out;
1394 }
1395 }
1396 if (visit_optional(v, "iops_size", &obj->has_iops_size)) {
1397 visit_type_int(v, "iops_size", &obj->iops_size, &err);
1398 if (err) {
1399 goto out;
1400 }
1401 }
1402 if (visit_optional(v, "group", &obj->has_group)) {
1403 visit_type_str(v, "group", &obj->group, &err);
1404 if (err) {
1405 goto out;
1406 }
1407 }
1408
1409out:
1410 error_propagate(errp, err);
1411}
1412
1413void visit_type_BlockIOThrottle(Visitor *v, const char *name, BlockIOThrottle **obj, Error **errp)
1414{
1415 Error *err = NULL;
1416
1417 visit_start_struct(v, name, (void **)obj, sizeof(BlockIOThrottle), &err);
1418 if (err) {
1419 goto out;
1420 }
1421 if (!*obj) {
1422 goto out_obj;
1423 }
1424 visit_type_BlockIOThrottle_members(v, *obj, &err);
1425 if (err) {
1426 goto out_obj;
1427 }
1428 visit_check_struct(v, &err);
1429out_obj:
1430 visit_end_struct(v, (void **)obj);
1431 if (err && visit_is_input(v)) {
1432 qapi_free_BlockIOThrottle(*obj);
1433 *obj = NULL;
1434 }
1435out:
1436 error_propagate(errp, err);
1437}
1438
1439void visit_type_BlockInfo_members(Visitor *v, BlockInfo *obj, Error **errp)
1440{
1441 Error *err = NULL;
1442
1443 visit_type_str(v, "device", &obj->device, &err);
1444 if (err) {
1445 goto out;
1446 }
1447 if (visit_optional(v, "qdev", &obj->has_qdev)) {
1448 visit_type_str(v, "qdev", &obj->qdev, &err);
1449 if (err) {
1450 goto out;
1451 }
1452 }
1453 visit_type_str(v, "type", &obj->type, &err);
1454 if (err) {
1455 goto out;
1456 }
1457 visit_type_bool(v, "removable", &obj->removable, &err);
1458 if (err) {
1459 goto out;
1460 }
1461 visit_type_bool(v, "locked", &obj->locked, &err);
1462 if (err) {
1463 goto out;
1464 }
1465 if (visit_optional(v, "inserted", &obj->has_inserted)) {
1466 visit_type_BlockDeviceInfo(v, "inserted", &obj->inserted, &err);
1467 if (err) {
1468 goto out;
1469 }
1470 }
1471 if (visit_optional(v, "tray_open", &obj->has_tray_open)) {
1472 visit_type_bool(v, "tray_open", &obj->tray_open, &err);
1473 if (err) {
1474 goto out;
1475 }
1476 }
1477 if (visit_optional(v, "io-status", &obj->has_io_status)) {
1478 visit_type_BlockDeviceIoStatus(v, "io-status", &obj->io_status, &err);
1479 if (err) {
1480 goto out;
1481 }
1482 }
1483 if (visit_optional(v, "dirty-bitmaps", &obj->has_dirty_bitmaps)) {
1484 visit_type_BlockDirtyInfoList(v, "dirty-bitmaps", &obj->dirty_bitmaps, &err);
1485 if (err) {
1486 goto out;
1487 }
1488 }
1489
1490out:
1491 error_propagate(errp, err);
1492}
1493
1494void visit_type_BlockInfo(Visitor *v, const char *name, BlockInfo **obj, Error **errp)
1495{
1496 Error *err = NULL;
1497
1498 visit_start_struct(v, name, (void **)obj, sizeof(BlockInfo), &err);
1499 if (err) {
1500 goto out;
1501 }
1502 if (!*obj) {
1503 goto out_obj;
1504 }
1505 visit_type_BlockInfo_members(v, *obj, &err);
1506 if (err) {
1507 goto out_obj;
1508 }
1509 visit_check_struct(v, &err);
1510out_obj:
1511 visit_end_struct(v, (void **)obj);
1512 if (err && visit_is_input(v)) {
1513 qapi_free_BlockInfo(*obj);
1514 *obj = NULL;
1515 }
1516out:
1517 error_propagate(errp, err);
1518}
1519
1520void visit_type_BlockInfoList(Visitor *v, const char *name, BlockInfoList **obj, Error **errp)
1521{
1522 Error *err = NULL;
1523 BlockInfoList *tail;
1524 size_t size = sizeof(**obj);
1525
1526 visit_start_list(v, name, (GenericList **)obj, size, &err);
1527 if (err) {
1528 goto out;
1529 }
1530
1531 for (tail = *obj; tail;
1532 tail = (BlockInfoList *)visit_next_list(v, (GenericList *)tail, size)) {
1533 visit_type_BlockInfo(v, NULL, &tail->value, &err);
1534 if (err) {
1535 break;
1536 }
1537 }
1538
1539 if (!err) {
1540 visit_check_list(v, &err);
1541 }
1542 visit_end_list(v, (void **)obj);
1543 if (err && visit_is_input(v)) {
1544 qapi_free_BlockInfoList(*obj);
1545 *obj = NULL;
1546 }
1547out:
1548 error_propagate(errp, err);
1549}
1550
1551void visit_type_BlockJobInfo_members(Visitor *v, BlockJobInfo *obj, Error **errp)
1552{
1553 Error *err = NULL;
1554
1555 visit_type_str(v, "type", &obj->type, &err);
1556 if (err) {
1557 goto out;
1558 }
1559 visit_type_str(v, "device", &obj->device, &err);
1560 if (err) {
1561 goto out;
1562 }
1563 visit_type_int(v, "len", &obj->len, &err);
1564 if (err) {
1565 goto out;
1566 }
1567 visit_type_int(v, "offset", &obj->offset, &err);
1568 if (err) {
1569 goto out;
1570 }
1571 visit_type_bool(v, "busy", &obj->busy, &err);
1572 if (err) {
1573 goto out;
1574 }
1575 visit_type_bool(v, "paused", &obj->paused, &err);
1576 if (err) {
1577 goto out;
1578 }
1579 visit_type_int(v, "speed", &obj->speed, &err);
1580 if (err) {
1581 goto out;
1582 }
1583 visit_type_BlockDeviceIoStatus(v, "io-status", &obj->io_status, &err);
1584 if (err) {
1585 goto out;
1586 }
1587 visit_type_bool(v, "ready", &obj->ready, &err);
1588 if (err) {
1589 goto out;
1590 }
1591
1592out:
1593 error_propagate(errp, err);
1594}
1595
1596void visit_type_BlockJobInfo(Visitor *v, const char *name, BlockJobInfo **obj, Error **errp)
1597{
1598 Error *err = NULL;
1599
1600 visit_start_struct(v, name, (void **)obj, sizeof(BlockJobInfo), &err);
1601 if (err) {
1602 goto out;
1603 }
1604 if (!*obj) {
1605 goto out_obj;
1606 }
1607 visit_type_BlockJobInfo_members(v, *obj, &err);
1608 if (err) {
1609 goto out_obj;
1610 }
1611 visit_check_struct(v, &err);
1612out_obj:
1613 visit_end_struct(v, (void **)obj);
1614 if (err && visit_is_input(v)) {
1615 qapi_free_BlockJobInfo(*obj);
1616 *obj = NULL;
1617 }
1618out:
1619 error_propagate(errp, err);
1620}
1621
1622void visit_type_BlockJobInfoList(Visitor *v, const char *name, BlockJobInfoList **obj, Error **errp)
1623{
1624 Error *err = NULL;
1625 BlockJobInfoList *tail;
1626 size_t size = sizeof(**obj);
1627
1628 visit_start_list(v, name, (GenericList **)obj, size, &err);
1629 if (err) {
1630 goto out;
1631 }
1632
1633 for (tail = *obj; tail;
1634 tail = (BlockJobInfoList *)visit_next_list(v, (GenericList *)tail, size)) {
1635 visit_type_BlockJobInfo(v, NULL, &tail->value, &err);
1636 if (err) {
1637 break;
1638 }
1639 }
1640
1641 if (!err) {
1642 visit_check_list(v, &err);
1643 }
1644 visit_end_list(v, (void **)obj);
1645 if (err && visit_is_input(v)) {
1646 qapi_free_BlockJobInfoList(*obj);
1647 *obj = NULL;
1648 }
1649out:
1650 error_propagate(errp, err);
1651}
1652
1653void visit_type_BlockJobType(Visitor *v, const char *name, BlockJobType *obj, Error **errp)
1654{
1655 int value = *obj;
1656 visit_type_enum(v, name, &value, BlockJobType_lookup, errp);
1657 *obj = value;
1658}
1659
1660void visit_type_BlockMeasureInfo_members(Visitor *v, BlockMeasureInfo *obj, Error **errp)
1661{
1662 Error *err = NULL;
1663
1664 visit_type_int(v, "required", &obj->required, &err);
1665 if (err) {
1666 goto out;
1667 }
1668 visit_type_int(v, "fully-allocated", &obj->fully_allocated, &err);
1669 if (err) {
1670 goto out;
1671 }
1672
1673out:
1674 error_propagate(errp, err);
1675}
1676
1677void visit_type_BlockMeasureInfo(Visitor *v, const char *name, BlockMeasureInfo **obj, Error **errp)
1678{
1679 Error *err = NULL;
1680
1681 visit_start_struct(v, name, (void **)obj, sizeof(BlockMeasureInfo), &err);
1682 if (err) {
1683 goto out;
1684 }
1685 if (!*obj) {
1686 goto out_obj;
1687 }
1688 visit_type_BlockMeasureInfo_members(v, *obj, &err);
1689 if (err) {
1690 goto out_obj;
1691 }
1692 visit_check_struct(v, &err);
1693out_obj:
1694 visit_end_struct(v, (void **)obj);
1695 if (err && visit_is_input(v)) {
1696 qapi_free_BlockMeasureInfo(*obj);
1697 *obj = NULL;
1698 }
1699out:
1700 error_propagate(errp, err);
1701}
1702
1703void visit_type_BlockStats_members(Visitor *v, BlockStats *obj, Error **errp)
1704{
1705 Error *err = NULL;
1706
1707 if (visit_optional(v, "device", &obj->has_device)) {
1708 visit_type_str(v, "device", &obj->device, &err);
1709 if (err) {
1710 goto out;
1711 }
1712 }
1713 if (visit_optional(v, "node-name", &obj->has_node_name)) {
1714 visit_type_str(v, "node-name", &obj->node_name, &err);
1715 if (err) {
1716 goto out;
1717 }
1718 }
1719 visit_type_BlockDeviceStats(v, "stats", &obj->stats, &err);
1720 if (err) {
1721 goto out;
1722 }
1723 if (visit_optional(v, "parent", &obj->has_parent)) {
1724 visit_type_BlockStats(v, "parent", &obj->parent, &err);
1725 if (err) {
1726 goto out;
1727 }
1728 }
1729 if (visit_optional(v, "backing", &obj->has_backing)) {
1730 visit_type_BlockStats(v, "backing", &obj->backing, &err);
1731 if (err) {
1732 goto out;
1733 }
1734 }
1735
1736out:
1737 error_propagate(errp, err);
1738}
1739
1740void visit_type_BlockStats(Visitor *v, const char *name, BlockStats **obj, Error **errp)
1741{
1742 Error *err = NULL;
1743
1744 visit_start_struct(v, name, (void **)obj, sizeof(BlockStats), &err);
1745 if (err) {
1746 goto out;
1747 }
1748 if (!*obj) {
1749 goto out_obj;
1750 }
1751 visit_type_BlockStats_members(v, *obj, &err);
1752 if (err) {
1753 goto out_obj;
1754 }
1755 visit_check_struct(v, &err);
1756out_obj:
1757 visit_end_struct(v, (void **)obj);
1758 if (err && visit_is_input(v)) {
1759 qapi_free_BlockStats(*obj);
1760 *obj = NULL;
1761 }
1762out:
1763 error_propagate(errp, err);
1764}
1765
1766void visit_type_BlockStatsList(Visitor *v, const char *name, BlockStatsList **obj, Error **errp)
1767{
1768 Error *err = NULL;
1769 BlockStatsList *tail;
1770 size_t size = sizeof(**obj);
1771
1772 visit_start_list(v, name, (GenericList **)obj, size, &err);
1773 if (err) {
1774 goto out;
1775 }
1776
1777 for (tail = *obj; tail;
1778 tail = (BlockStatsList *)visit_next_list(v, (GenericList *)tail, size)) {
1779 visit_type_BlockStats(v, NULL, &tail->value, &err);
1780 if (err) {
1781 break;
1782 }
1783 }
1784
1785 if (!err) {
1786 visit_check_list(v, &err);
1787 }
1788 visit_end_list(v, (void **)obj);
1789 if (err && visit_is_input(v)) {
1790 qapi_free_BlockStatsList(*obj);
1791 *obj = NULL;
1792 }
1793out:
1794 error_propagate(errp, err);
1795}
1796
1797void visit_type_BlockdevAioOptions(Visitor *v, const char *name, BlockdevAioOptions *obj, Error **errp)
1798{
1799 int value = *obj;
1800 visit_type_enum(v, name, &value, BlockdevAioOptions_lookup, errp);
1801 *obj = value;
1802}
1803
1804void visit_type_BlockdevBackup_members(Visitor *v, BlockdevBackup *obj, Error **errp)
1805{
1806 Error *err = NULL;
1807
1808 if (visit_optional(v, "job-id", &obj->has_job_id)) {
1809 visit_type_str(v, "job-id", &obj->job_id, &err);
1810 if (err) {
1811 goto out;
1812 }
1813 }
1814 visit_type_str(v, "device", &obj->device, &err);
1815 if (err) {
1816 goto out;
1817 }
1818 visit_type_str(v, "target", &obj->target, &err);
1819 if (err) {
1820 goto out;
1821 }
1822 visit_type_MirrorSyncMode(v, "sync", &obj->sync, &err);
1823 if (err) {
1824 goto out;
1825 }
1826 if (visit_optional(v, "speed", &obj->has_speed)) {
1827 visit_type_int(v, "speed", &obj->speed, &err);
1828 if (err) {
1829 goto out;
1830 }
1831 }
1832 if (visit_optional(v, "compress", &obj->has_compress)) {
1833 visit_type_bool(v, "compress", &obj->compress, &err);
1834 if (err) {
1835 goto out;
1836 }
1837 }
1838 if (visit_optional(v, "on-source-error", &obj->has_on_source_error)) {
1839 visit_type_BlockdevOnError(v, "on-source-error", &obj->on_source_error, &err);
1840 if (err) {
1841 goto out;
1842 }
1843 }
1844 if (visit_optional(v, "on-target-error", &obj->has_on_target_error)) {
1845 visit_type_BlockdevOnError(v, "on-target-error", &obj->on_target_error, &err);
1846 if (err) {
1847 goto out;
1848 }
1849 }
1850
1851out:
1852 error_propagate(errp, err);
1853}
1854
1855void visit_type_BlockdevBackup(Visitor *v, const char *name, BlockdevBackup **obj, Error **errp)
1856{
1857 Error *err = NULL;
1858
1859 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevBackup), &err);
1860 if (err) {
1861 goto out;
1862 }
1863 if (!*obj) {
1864 goto out_obj;
1865 }
1866 visit_type_BlockdevBackup_members(v, *obj, &err);
1867 if (err) {
1868 goto out_obj;
1869 }
1870 visit_check_struct(v, &err);
1871out_obj:
1872 visit_end_struct(v, (void **)obj);
1873 if (err && visit_is_input(v)) {
1874 qapi_free_BlockdevBackup(*obj);
1875 *obj = NULL;
1876 }
1877out:
1878 error_propagate(errp, err);
1879}
1880
1881void visit_type_BlockdevCacheInfo_members(Visitor *v, BlockdevCacheInfo *obj, Error **errp)
1882{
1883 Error *err = NULL;
1884
1885 visit_type_bool(v, "writeback", &obj->writeback, &err);
1886 if (err) {
1887 goto out;
1888 }
1889 visit_type_bool(v, "direct", &obj->direct, &err);
1890 if (err) {
1891 goto out;
1892 }
1893 visit_type_bool(v, "no-flush", &obj->no_flush, &err);
1894 if (err) {
1895 goto out;
1896 }
1897
1898out:
1899 error_propagate(errp, err);
1900}
1901
1902void visit_type_BlockdevCacheInfo(Visitor *v, const char *name, BlockdevCacheInfo **obj, Error **errp)
1903{
1904 Error *err = NULL;
1905
1906 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevCacheInfo), &err);
1907 if (err) {
1908 goto out;
1909 }
1910 if (!*obj) {
1911 goto out_obj;
1912 }
1913 visit_type_BlockdevCacheInfo_members(v, *obj, &err);
1914 if (err) {
1915 goto out_obj;
1916 }
1917 visit_check_struct(v, &err);
1918out_obj:
1919 visit_end_struct(v, (void **)obj);
1920 if (err && visit_is_input(v)) {
1921 qapi_free_BlockdevCacheInfo(*obj);
1922 *obj = NULL;
1923 }
1924out:
1925 error_propagate(errp, err);
1926}
1927
1928void visit_type_BlockdevCacheOptions_members(Visitor *v, BlockdevCacheOptions *obj, Error **errp)
1929{
1930 Error *err = NULL;
1931
1932 if (visit_optional(v, "direct", &obj->has_direct)) {
1933 visit_type_bool(v, "direct", &obj->direct, &err);
1934 if (err) {
1935 goto out;
1936 }
1937 }
1938 if (visit_optional(v, "no-flush", &obj->has_no_flush)) {
1939 visit_type_bool(v, "no-flush", &obj->no_flush, &err);
1940 if (err) {
1941 goto out;
1942 }
1943 }
1944
1945out:
1946 error_propagate(errp, err);
1947}
1948
1949void visit_type_BlockdevCacheOptions(Visitor *v, const char *name, BlockdevCacheOptions **obj, Error **errp)
1950{
1951 Error *err = NULL;
1952
1953 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevCacheOptions), &err);
1954 if (err) {
1955 goto out;
1956 }
1957 if (!*obj) {
1958 goto out_obj;
1959 }
1960 visit_type_BlockdevCacheOptions_members(v, *obj, &err);
1961 if (err) {
1962 goto out_obj;
1963 }
1964 visit_check_struct(v, &err);
1965out_obj:
1966 visit_end_struct(v, (void **)obj);
1967 if (err && visit_is_input(v)) {
1968 qapi_free_BlockdevCacheOptions(*obj);
1969 *obj = NULL;
1970 }
1971out:
1972 error_propagate(errp, err);
1973}
1974
1975void visit_type_BlockdevChangeReadOnlyMode(Visitor *v, const char *name, BlockdevChangeReadOnlyMode *obj, Error **errp)
1976{
1977 int value = *obj;
1978 visit_type_enum(v, name, &value, BlockdevChangeReadOnlyMode_lookup, errp);
1979 *obj = value;
1980}
1981
1982void visit_type_BlockdevDetectZeroesOptions(Visitor *v, const char *name, BlockdevDetectZeroesOptions *obj, Error **errp)
1983{
1984 int value = *obj;
1985 visit_type_enum(v, name, &value, BlockdevDetectZeroesOptions_lookup, errp);
1986 *obj = value;
1987}
1988
1989void visit_type_BlockdevDiscardOptions(Visitor *v, const char *name, BlockdevDiscardOptions *obj, Error **errp)
1990{
1991 int value = *obj;
1992 visit_type_enum(v, name, &value, BlockdevDiscardOptions_lookup, errp);
1993 *obj = value;
1994}
1995
1996void visit_type_BlockdevDriver(Visitor *v, const char *name, BlockdevDriver *obj, Error **errp)
1997{
1998 int value = *obj;
1999 visit_type_enum(v, name, &value, BlockdevDriver_lookup, errp);
2000 *obj = value;
2001}
2002
2003void visit_type_BlockdevOnError(Visitor *v, const char *name, BlockdevOnError *obj, Error **errp)
2004{
2005 int value = *obj;
2006 visit_type_enum(v, name, &value, BlockdevOnError_lookup, errp);
2007 *obj = value;
2008}
2009
2010void visit_type_BlockdevOptions_members(Visitor *v, BlockdevOptions *obj, Error **errp)
2011{
2012 Error *err = NULL;
2013
2014 visit_type_q_obj_BlockdevOptions_base_members(v, (q_obj_BlockdevOptions_base *)obj, &err);
2015 if (err) {
2016 goto out;
2017 }
2018 switch (obj->driver) {
2019 case BLOCKDEV_DRIVER_BLKDEBUG:
2020 visit_type_BlockdevOptionsBlkdebug_members(v, &obj->u.blkdebug, &err);
2021 break;
2022 case BLOCKDEV_DRIVER_BLKVERIFY:
2023 visit_type_BlockdevOptionsBlkverify_members(v, &obj->u.blkverify, &err);
2024 break;
2025 case BLOCKDEV_DRIVER_BOCHS:
2026 visit_type_BlockdevOptionsGenericFormat_members(v, &obj->u.bochs, &err);
2027 break;
2028 case BLOCKDEV_DRIVER_CLOOP:
2029 visit_type_BlockdevOptionsGenericFormat_members(v, &obj->u.cloop, &err);
2030 break;
2031 case BLOCKDEV_DRIVER_DMG:
2032 visit_type_BlockdevOptionsGenericFormat_members(v, &obj->u.dmg, &err);
2033 break;
2034 case BLOCKDEV_DRIVER_FILE:
2035 visit_type_BlockdevOptionsFile_members(v, &obj->u.file, &err);
2036 break;
2037 case BLOCKDEV_DRIVER_FTP:
2038 visit_type_BlockdevOptionsCurlFtp_members(v, &obj->u.ftp, &err);
2039 break;
2040 case BLOCKDEV_DRIVER_FTPS:
2041 visit_type_BlockdevOptionsCurlFtps_members(v, &obj->u.ftps, &err);
2042 break;
2043 case BLOCKDEV_DRIVER_GLUSTER:
2044 visit_type_BlockdevOptionsGluster_members(v, &obj->u.gluster, &err);
2045 break;
2046 case BLOCKDEV_DRIVER_HOST_CDROM:
2047 visit_type_BlockdevOptionsFile_members(v, &obj->u.host_cdrom, &err);
2048 break;
2049 case BLOCKDEV_DRIVER_HOST_DEVICE:
2050 visit_type_BlockdevOptionsFile_members(v, &obj->u.host_device, &err);
2051 break;
2052 case BLOCKDEV_DRIVER_HTTP:
2053 visit_type_BlockdevOptionsCurlHttp_members(v, &obj->u.http, &err);
2054 break;
2055 case BLOCKDEV_DRIVER_HTTPS:
2056 visit_type_BlockdevOptionsCurlHttps_members(v, &obj->u.https, &err);
2057 break;
2058 case BLOCKDEV_DRIVER_ISCSI:
2059 visit_type_BlockdevOptionsIscsi_members(v, &obj->u.iscsi, &err);
2060 break;
2061 case BLOCKDEV_DRIVER_LUKS:
2062 visit_type_BlockdevOptionsLUKS_members(v, &obj->u.luks, &err);
2063 break;
2064 case BLOCKDEV_DRIVER_NBD:
2065 visit_type_BlockdevOptionsNbd_members(v, &obj->u.nbd, &err);
2066 break;
2067 case BLOCKDEV_DRIVER_NFS:
2068 visit_type_BlockdevOptionsNfs_members(v, &obj->u.nfs, &err);
2069 break;
2070 case BLOCKDEV_DRIVER_NULL_AIO:
2071 visit_type_BlockdevOptionsNull_members(v, &obj->u.null_aio, &err);
2072 break;
2073 case BLOCKDEV_DRIVER_NULL_CO:
2074 visit_type_BlockdevOptionsNull_members(v, &obj->u.null_co, &err);
2075 break;
2076 case BLOCKDEV_DRIVER_PARALLELS:
2077 visit_type_BlockdevOptionsGenericFormat_members(v, &obj->u.parallels, &err);
2078 break;
2079 case BLOCKDEV_DRIVER_QCOW2:
2080 visit_type_BlockdevOptionsQcow2_members(v, &obj->u.qcow2, &err);
2081 break;
2082 case BLOCKDEV_DRIVER_QCOW:
2083 visit_type_BlockdevOptionsQcow_members(v, &obj->u.qcow, &err);
2084 break;
2085 case BLOCKDEV_DRIVER_QED:
2086 visit_type_BlockdevOptionsGenericCOWFormat_members(v, &obj->u.qed, &err);
2087 break;
2088 case BLOCKDEV_DRIVER_QUORUM:
2089 visit_type_BlockdevOptionsQuorum_members(v, &obj->u.quorum, &err);
2090 break;
2091 case BLOCKDEV_DRIVER_RAW:
2092 visit_type_BlockdevOptionsRaw_members(v, &obj->u.raw, &err);
2093 break;
2094 case BLOCKDEV_DRIVER_RBD:
2095 visit_type_BlockdevOptionsRbd_members(v, &obj->u.rbd, &err);
2096 break;
2097 case BLOCKDEV_DRIVER_REPLICATION:
2098 visit_type_BlockdevOptionsReplication_members(v, &obj->u.replication, &err);
2099 break;
2100 case BLOCKDEV_DRIVER_SHEEPDOG:
2101 visit_type_BlockdevOptionsSheepdog_members(v, &obj->u.sheepdog, &err);
2102 break;
2103 case BLOCKDEV_DRIVER_SSH:
2104 visit_type_BlockdevOptionsSsh_members(v, &obj->u.ssh, &err);
2105 break;
2106 case BLOCKDEV_DRIVER_VDI:
2107 visit_type_BlockdevOptionsGenericFormat_members(v, &obj->u.vdi, &err);
2108 break;
2109 case BLOCKDEV_DRIVER_VHDX:
2110 visit_type_BlockdevOptionsGenericFormat_members(v, &obj->u.vhdx, &err);
2111 break;
2112 case BLOCKDEV_DRIVER_VMDK:
2113 visit_type_BlockdevOptionsGenericCOWFormat_members(v, &obj->u.vmdk, &err);
2114 break;
2115 case BLOCKDEV_DRIVER_VPC:
2116 visit_type_BlockdevOptionsGenericFormat_members(v, &obj->u.vpc, &err);
2117 break;
2118 case BLOCKDEV_DRIVER_VVFAT:
2119 visit_type_BlockdevOptionsVVFAT_members(v, &obj->u.vvfat, &err);
2120 break;
2121 case BLOCKDEV_DRIVER_VXHS:
2122 visit_type_BlockdevOptionsVxHS_members(v, &obj->u.vxhs, &err);
2123 break;
2124 default:
2125 abort();
2126 }
2127
2128out:
2129 error_propagate(errp, err);
2130}
2131
2132void visit_type_BlockdevOptions(Visitor *v, const char *name, BlockdevOptions **obj, Error **errp)
2133{
2134 Error *err = NULL;
2135
2136 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptions), &err);
2137 if (err) {
2138 goto out;
2139 }
2140 if (!*obj) {
2141 goto out_obj;
2142 }
2143 visit_type_BlockdevOptions_members(v, *obj, &err);
2144 if (err) {
2145 goto out_obj;
2146 }
2147 visit_check_struct(v, &err);
2148out_obj:
2149 visit_end_struct(v, (void **)obj);
2150 if (err && visit_is_input(v)) {
2151 qapi_free_BlockdevOptions(*obj);
2152 *obj = NULL;
2153 }
2154out:
2155 error_propagate(errp, err);
2156}
2157
2158void visit_type_BlockdevOptionsBlkdebug_members(Visitor *v, BlockdevOptionsBlkdebug *obj, Error **errp)
2159{
2160 Error *err = NULL;
2161
2162 visit_type_BlockdevRef(v, "image", &obj->image, &err);
2163 if (err) {
2164 goto out;
2165 }
2166 if (visit_optional(v, "config", &obj->has_config)) {
2167 visit_type_str(v, "config", &obj->config, &err);
2168 if (err) {
2169 goto out;
2170 }
2171 }
2172 if (visit_optional(v, "align", &obj->has_align)) {
2173 visit_type_int(v, "align", &obj->align, &err);
2174 if (err) {
2175 goto out;
2176 }
2177 }
2178 if (visit_optional(v, "max-transfer", &obj->has_max_transfer)) {
2179 visit_type_int32(v, "max-transfer", &obj->max_transfer, &err);
2180 if (err) {
2181 goto out;
2182 }
2183 }
2184 if (visit_optional(v, "opt-write-zero", &obj->has_opt_write_zero)) {
2185 visit_type_int32(v, "opt-write-zero", &obj->opt_write_zero, &err);
2186 if (err) {
2187 goto out;
2188 }
2189 }
2190 if (visit_optional(v, "max-write-zero", &obj->has_max_write_zero)) {
2191 visit_type_int32(v, "max-write-zero", &obj->max_write_zero, &err);
2192 if (err) {
2193 goto out;
2194 }
2195 }
2196 if (visit_optional(v, "opt-discard", &obj->has_opt_discard)) {
2197 visit_type_int32(v, "opt-discard", &obj->opt_discard, &err);
2198 if (err) {
2199 goto out;
2200 }
2201 }
2202 if (visit_optional(v, "max-discard", &obj->has_max_discard)) {
2203 visit_type_int32(v, "max-discard", &obj->max_discard, &err);
2204 if (err) {
2205 goto out;
2206 }
2207 }
2208 if (visit_optional(v, "inject-error", &obj->has_inject_error)) {
2209 visit_type_BlkdebugInjectErrorOptionsList(v, "inject-error", &obj->inject_error, &err);
2210 if (err) {
2211 goto out;
2212 }
2213 }
2214 if (visit_optional(v, "set-state", &obj->has_set_state)) {
2215 visit_type_BlkdebugSetStateOptionsList(v, "set-state", &obj->set_state, &err);
2216 if (err) {
2217 goto out;
2218 }
2219 }
2220
2221out:
2222 error_propagate(errp, err);
2223}
2224
2225void visit_type_BlockdevOptionsBlkdebug(Visitor *v, const char *name, BlockdevOptionsBlkdebug **obj, Error **errp)
2226{
2227 Error *err = NULL;
2228
2229 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptionsBlkdebug), &err);
2230 if (err) {
2231 goto out;
2232 }
2233 if (!*obj) {
2234 goto out_obj;
2235 }
2236 visit_type_BlockdevOptionsBlkdebug_members(v, *obj, &err);
2237 if (err) {
2238 goto out_obj;
2239 }
2240 visit_check_struct(v, &err);
2241out_obj:
2242 visit_end_struct(v, (void **)obj);
2243 if (err && visit_is_input(v)) {
2244 qapi_free_BlockdevOptionsBlkdebug(*obj);
2245 *obj = NULL;
2246 }
2247out:
2248 error_propagate(errp, err);
2249}
2250
2251void visit_type_BlockdevOptionsBlkverify_members(Visitor *v, BlockdevOptionsBlkverify *obj, Error **errp)
2252{
2253 Error *err = NULL;
2254
2255 visit_type_BlockdevRef(v, "test", &obj->test, &err);
2256 if (err) {
2257 goto out;
2258 }
2259 visit_type_BlockdevRef(v, "raw", &obj->raw, &err);
2260 if (err) {
2261 goto out;
2262 }
2263
2264out:
2265 error_propagate(errp, err);
2266}
2267
2268void visit_type_BlockdevOptionsBlkverify(Visitor *v, const char *name, BlockdevOptionsBlkverify **obj, Error **errp)
2269{
2270 Error *err = NULL;
2271
2272 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptionsBlkverify), &err);
2273 if (err) {
2274 goto out;
2275 }
2276 if (!*obj) {
2277 goto out_obj;
2278 }
2279 visit_type_BlockdevOptionsBlkverify_members(v, *obj, &err);
2280 if (err) {
2281 goto out_obj;
2282 }
2283 visit_check_struct(v, &err);
2284out_obj:
2285 visit_end_struct(v, (void **)obj);
2286 if (err && visit_is_input(v)) {
2287 qapi_free_BlockdevOptionsBlkverify(*obj);
2288 *obj = NULL;
2289 }
2290out:
2291 error_propagate(errp, err);
2292}
2293
2294void visit_type_BlockdevOptionsCurlBase_members(Visitor *v, BlockdevOptionsCurlBase *obj, Error **errp)
2295{
2296 Error *err = NULL;
2297
2298 visit_type_str(v, "url", &obj->url, &err);
2299 if (err) {
2300 goto out;
2301 }
2302 if (visit_optional(v, "readahead", &obj->has_readahead)) {
2303 visit_type_int(v, "readahead", &obj->readahead, &err);
2304 if (err) {
2305 goto out;
2306 }
2307 }
2308 if (visit_optional(v, "timeout", &obj->has_timeout)) {
2309 visit_type_int(v, "timeout", &obj->timeout, &err);
2310 if (err) {
2311 goto out;
2312 }
2313 }
2314 if (visit_optional(v, "username", &obj->has_username)) {
2315 visit_type_str(v, "username", &obj->username, &err);
2316 if (err) {
2317 goto out;
2318 }
2319 }
2320 if (visit_optional(v, "password-secret", &obj->has_password_secret)) {
2321 visit_type_str(v, "password-secret", &obj->password_secret, &err);
2322 if (err) {
2323 goto out;
2324 }
2325 }
2326 if (visit_optional(v, "proxy-username", &obj->has_proxy_username)) {
2327 visit_type_str(v, "proxy-username", &obj->proxy_username, &err);
2328 if (err) {
2329 goto out;
2330 }
2331 }
2332 if (visit_optional(v, "proxy-password-secret", &obj->has_proxy_password_secret)) {
2333 visit_type_str(v, "proxy-password-secret", &obj->proxy_password_secret, &err);
2334 if (err) {
2335 goto out;
2336 }
2337 }
2338
2339out:
2340 error_propagate(errp, err);
2341}
2342
2343void visit_type_BlockdevOptionsCurlBase(Visitor *v, const char *name, BlockdevOptionsCurlBase **obj, Error **errp)
2344{
2345 Error *err = NULL;
2346
2347 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptionsCurlBase), &err);
2348 if (err) {
2349 goto out;
2350 }
2351 if (!*obj) {
2352 goto out_obj;
2353 }
2354 visit_type_BlockdevOptionsCurlBase_members(v, *obj, &err);
2355 if (err) {
2356 goto out_obj;
2357 }
2358 visit_check_struct(v, &err);
2359out_obj:
2360 visit_end_struct(v, (void **)obj);
2361 if (err && visit_is_input(v)) {
2362 qapi_free_BlockdevOptionsCurlBase(*obj);
2363 *obj = NULL;
2364 }
2365out:
2366 error_propagate(errp, err);
2367}
2368
2369void visit_type_BlockdevOptionsCurlFtp_members(Visitor *v, BlockdevOptionsCurlFtp *obj, Error **errp)
2370{
2371 Error *err = NULL;
2372
2373 visit_type_BlockdevOptionsCurlBase_members(v, (BlockdevOptionsCurlBase *)obj, &err);
2374 if (err) {
2375 goto out;
2376 }
2377
2378out:
2379 error_propagate(errp, err);
2380}
2381
2382void visit_type_BlockdevOptionsCurlFtp(Visitor *v, const char *name, BlockdevOptionsCurlFtp **obj, Error **errp)
2383{
2384 Error *err = NULL;
2385
2386 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptionsCurlFtp), &err);
2387 if (err) {
2388 goto out;
2389 }
2390 if (!*obj) {
2391 goto out_obj;
2392 }
2393 visit_type_BlockdevOptionsCurlFtp_members(v, *obj, &err);
2394 if (err) {
2395 goto out_obj;
2396 }
2397 visit_check_struct(v, &err);
2398out_obj:
2399 visit_end_struct(v, (void **)obj);
2400 if (err && visit_is_input(v)) {
2401 qapi_free_BlockdevOptionsCurlFtp(*obj);
2402 *obj = NULL;
2403 }
2404out:
2405 error_propagate(errp, err);
2406}
2407
2408void visit_type_BlockdevOptionsCurlFtps_members(Visitor *v, BlockdevOptionsCurlFtps *obj, Error **errp)
2409{
2410 Error *err = NULL;
2411
2412 visit_type_BlockdevOptionsCurlBase_members(v, (BlockdevOptionsCurlBase *)obj, &err);
2413 if (err) {
2414 goto out;
2415 }
2416 if (visit_optional(v, "sslverify", &obj->has_sslverify)) {
2417 visit_type_bool(v, "sslverify", &obj->sslverify, &err);
2418 if (err) {
2419 goto out;
2420 }
2421 }
2422
2423out:
2424 error_propagate(errp, err);
2425}
2426
2427void visit_type_BlockdevOptionsCurlFtps(Visitor *v, const char *name, BlockdevOptionsCurlFtps **obj, Error **errp)
2428{
2429 Error *err = NULL;
2430
2431 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptionsCurlFtps), &err);
2432 if (err) {
2433 goto out;
2434 }
2435 if (!*obj) {
2436 goto out_obj;
2437 }
2438 visit_type_BlockdevOptionsCurlFtps_members(v, *obj, &err);
2439 if (err) {
2440 goto out_obj;
2441 }
2442 visit_check_struct(v, &err);
2443out_obj:
2444 visit_end_struct(v, (void **)obj);
2445 if (err && visit_is_input(v)) {
2446 qapi_free_BlockdevOptionsCurlFtps(*obj);
2447 *obj = NULL;
2448 }
2449out:
2450 error_propagate(errp, err);
2451}
2452
2453void visit_type_BlockdevOptionsCurlHttp_members(Visitor *v, BlockdevOptionsCurlHttp *obj, Error **errp)
2454{
2455 Error *err = NULL;
2456
2457 visit_type_BlockdevOptionsCurlBase_members(v, (BlockdevOptionsCurlBase *)obj, &err);
2458 if (err) {
2459 goto out;
2460 }
2461 if (visit_optional(v, "cookie", &obj->has_cookie)) {
2462 visit_type_str(v, "cookie", &obj->cookie, &err);
2463 if (err) {
2464 goto out;
2465 }
2466 }
2467 if (visit_optional(v, "cookie-secret", &obj->has_cookie_secret)) {
2468 visit_type_str(v, "cookie-secret", &obj->cookie_secret, &err);
2469 if (err) {
2470 goto out;
2471 }
2472 }
2473
2474out:
2475 error_propagate(errp, err);
2476}
2477
2478void visit_type_BlockdevOptionsCurlHttp(Visitor *v, const char *name, BlockdevOptionsCurlHttp **obj, Error **errp)
2479{
2480 Error *err = NULL;
2481
2482 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptionsCurlHttp), &err);
2483 if (err) {
2484 goto out;
2485 }
2486 if (!*obj) {
2487 goto out_obj;
2488 }
2489 visit_type_BlockdevOptionsCurlHttp_members(v, *obj, &err);
2490 if (err) {
2491 goto out_obj;
2492 }
2493 visit_check_struct(v, &err);
2494out_obj:
2495 visit_end_struct(v, (void **)obj);
2496 if (err && visit_is_input(v)) {
2497 qapi_free_BlockdevOptionsCurlHttp(*obj);
2498 *obj = NULL;
2499 }
2500out:
2501 error_propagate(errp, err);
2502}
2503
2504void visit_type_BlockdevOptionsCurlHttps_members(Visitor *v, BlockdevOptionsCurlHttps *obj, Error **errp)
2505{
2506 Error *err = NULL;
2507
2508 visit_type_BlockdevOptionsCurlBase_members(v, (BlockdevOptionsCurlBase *)obj, &err);
2509 if (err) {
2510 goto out;
2511 }
2512 if (visit_optional(v, "cookie", &obj->has_cookie)) {
2513 visit_type_str(v, "cookie", &obj->cookie, &err);
2514 if (err) {
2515 goto out;
2516 }
2517 }
2518 if (visit_optional(v, "sslverify", &obj->has_sslverify)) {
2519 visit_type_bool(v, "sslverify", &obj->sslverify, &err);
2520 if (err) {
2521 goto out;
2522 }
2523 }
2524 if (visit_optional(v, "cookie-secret", &obj->has_cookie_secret)) {
2525 visit_type_str(v, "cookie-secret", &obj->cookie_secret, &err);
2526 if (err) {
2527 goto out;
2528 }
2529 }
2530
2531out:
2532 error_propagate(errp, err);
2533}
2534
2535void visit_type_BlockdevOptionsCurlHttps(Visitor *v, const char *name, BlockdevOptionsCurlHttps **obj, Error **errp)
2536{
2537 Error *err = NULL;
2538
2539 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptionsCurlHttps), &err);
2540 if (err) {
2541 goto out;
2542 }
2543 if (!*obj) {
2544 goto out_obj;
2545 }
2546 visit_type_BlockdevOptionsCurlHttps_members(v, *obj, &err);
2547 if (err) {
2548 goto out_obj;
2549 }
2550 visit_check_struct(v, &err);
2551out_obj:
2552 visit_end_struct(v, (void **)obj);
2553 if (err && visit_is_input(v)) {
2554 qapi_free_BlockdevOptionsCurlHttps(*obj);
2555 *obj = NULL;
2556 }
2557out:
2558 error_propagate(errp, err);
2559}
2560
2561void visit_type_BlockdevOptionsFile_members(Visitor *v, BlockdevOptionsFile *obj, Error **errp)
2562{
2563 Error *err = NULL;
2564
2565 visit_type_str(v, "filename", &obj->filename, &err);
2566 if (err) {
2567 goto out;
2568 }
2569 if (visit_optional(v, "locking", &obj->has_locking)) {
2570 visit_type_OnOffAuto(v, "locking", &obj->locking, &err);
2571 if (err) {
2572 goto out;
2573 }
2574 }
2575 if (visit_optional(v, "aio", &obj->has_aio)) {
2576 visit_type_BlockdevAioOptions(v, "aio", &obj->aio, &err);
2577 if (err) {
2578 goto out;
2579 }
2580 }
2581
2582out:
2583 error_propagate(errp, err);
2584}
2585
2586void visit_type_BlockdevOptionsFile(Visitor *v, const char *name, BlockdevOptionsFile **obj, Error **errp)
2587{
2588 Error *err = NULL;
2589
2590 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptionsFile), &err);
2591 if (err) {
2592 goto out;
2593 }
2594 if (!*obj) {
2595 goto out_obj;
2596 }
2597 visit_type_BlockdevOptionsFile_members(v, *obj, &err);
2598 if (err) {
2599 goto out_obj;
2600 }
2601 visit_check_struct(v, &err);
2602out_obj:
2603 visit_end_struct(v, (void **)obj);
2604 if (err && visit_is_input(v)) {
2605 qapi_free_BlockdevOptionsFile(*obj);
2606 *obj = NULL;
2607 }
2608out:
2609 error_propagate(errp, err);
2610}
2611
2612void visit_type_BlockdevOptionsGenericCOWFormat_members(Visitor *v, BlockdevOptionsGenericCOWFormat *obj, Error **errp)
2613{
2614 Error *err = NULL;
2615
2616 visit_type_BlockdevOptionsGenericFormat_members(v, (BlockdevOptionsGenericFormat *)obj, &err);
2617 if (err) {
2618 goto out;
2619 }
2620 if (visit_optional(v, "backing", &obj->has_backing)) {
2621 visit_type_BlockdevRefOrNull(v, "backing", &obj->backing, &err);
2622 if (err) {
2623 goto out;
2624 }
2625 }
2626
2627out:
2628 error_propagate(errp, err);
2629}
2630
2631void visit_type_BlockdevOptionsGenericCOWFormat(Visitor *v, const char *name, BlockdevOptionsGenericCOWFormat **obj, Error **errp)
2632{
2633 Error *err = NULL;
2634
2635 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptionsGenericCOWFormat), &err);
2636 if (err) {
2637 goto out;
2638 }
2639 if (!*obj) {
2640 goto out_obj;
2641 }
2642 visit_type_BlockdevOptionsGenericCOWFormat_members(v, *obj, &err);
2643 if (err) {
2644 goto out_obj;
2645 }
2646 visit_check_struct(v, &err);
2647out_obj:
2648 visit_end_struct(v, (void **)obj);
2649 if (err && visit_is_input(v)) {
2650 qapi_free_BlockdevOptionsGenericCOWFormat(*obj);
2651 *obj = NULL;
2652 }
2653out:
2654 error_propagate(errp, err);
2655}
2656
2657void visit_type_BlockdevOptionsGenericFormat_members(Visitor *v, BlockdevOptionsGenericFormat *obj, Error **errp)
2658{
2659 Error *err = NULL;
2660
2661 visit_type_BlockdevRef(v, "file", &obj->file, &err);
2662 if (err) {
2663 goto out;
2664 }
2665
2666out:
2667 error_propagate(errp, err);
2668}
2669
2670void visit_type_BlockdevOptionsGenericFormat(Visitor *v, const char *name, BlockdevOptionsGenericFormat **obj, Error **errp)
2671{
2672 Error *err = NULL;
2673
2674 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptionsGenericFormat), &err);
2675 if (err) {
2676 goto out;
2677 }
2678 if (!*obj) {
2679 goto out_obj;
2680 }
2681 visit_type_BlockdevOptionsGenericFormat_members(v, *obj, &err);
2682 if (err) {
2683 goto out_obj;
2684 }
2685 visit_check_struct(v, &err);
2686out_obj:
2687 visit_end_struct(v, (void **)obj);
2688 if (err && visit_is_input(v)) {
2689 qapi_free_BlockdevOptionsGenericFormat(*obj);
2690 *obj = NULL;
2691 }
2692out:
2693 error_propagate(errp, err);
2694}
2695
2696void visit_type_BlockdevOptionsGluster_members(Visitor *v, BlockdevOptionsGluster *obj, Error **errp)
2697{
2698 Error *err = NULL;
2699
2700 visit_type_str(v, "volume", &obj->volume, &err);
2701 if (err) {
2702 goto out;
2703 }
2704 visit_type_str(v, "path", &obj->path, &err);
2705 if (err) {
2706 goto out;
2707 }
2708 visit_type_SocketAddressList(v, "server", &obj->server, &err);
2709 if (err) {
2710 goto out;
2711 }
2712 if (visit_optional(v, "debug", &obj->has_debug)) {
2713 visit_type_int(v, "debug", &obj->debug, &err);
2714 if (err) {
2715 goto out;
2716 }
2717 }
2718 if (visit_optional(v, "logfile", &obj->has_logfile)) {
2719 visit_type_str(v, "logfile", &obj->logfile, &err);
2720 if (err) {
2721 goto out;
2722 }
2723 }
2724
2725out:
2726 error_propagate(errp, err);
2727}
2728
2729void visit_type_BlockdevOptionsGluster(Visitor *v, const char *name, BlockdevOptionsGluster **obj, Error **errp)
2730{
2731 Error *err = NULL;
2732
2733 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptionsGluster), &err);
2734 if (err) {
2735 goto out;
2736 }
2737 if (!*obj) {
2738 goto out_obj;
2739 }
2740 visit_type_BlockdevOptionsGluster_members(v, *obj, &err);
2741 if (err) {
2742 goto out_obj;
2743 }
2744 visit_check_struct(v, &err);
2745out_obj:
2746 visit_end_struct(v, (void **)obj);
2747 if (err && visit_is_input(v)) {
2748 qapi_free_BlockdevOptionsGluster(*obj);
2749 *obj = NULL;
2750 }
2751out:
2752 error_propagate(errp, err);
2753}
2754
2755void visit_type_BlockdevOptionsIscsi_members(Visitor *v, BlockdevOptionsIscsi *obj, Error **errp)
2756{
2757 Error *err = NULL;
2758
2759 visit_type_IscsiTransport(v, "transport", &obj->transport, &err);
2760 if (err) {
2761 goto out;
2762 }
2763 visit_type_str(v, "portal", &obj->portal, &err);
2764 if (err) {
2765 goto out;
2766 }
2767 visit_type_str(v, "target", &obj->target, &err);
2768 if (err) {
2769 goto out;
2770 }
2771 if (visit_optional(v, "lun", &obj->has_lun)) {
2772 visit_type_int(v, "lun", &obj->lun, &err);
2773 if (err) {
2774 goto out;
2775 }
2776 }
2777 if (visit_optional(v, "user", &obj->has_user)) {
2778 visit_type_str(v, "user", &obj->user, &err);
2779 if (err) {
2780 goto out;
2781 }
2782 }
2783 if (visit_optional(v, "password-secret", &obj->has_password_secret)) {
2784 visit_type_str(v, "password-secret", &obj->password_secret, &err);
2785 if (err) {
2786 goto out;
2787 }
2788 }
2789 if (visit_optional(v, "initiator-name", &obj->has_initiator_name)) {
2790 visit_type_str(v, "initiator-name", &obj->initiator_name, &err);
2791 if (err) {
2792 goto out;
2793 }
2794 }
2795 if (visit_optional(v, "header-digest", &obj->has_header_digest)) {
2796 visit_type_IscsiHeaderDigest(v, "header-digest", &obj->header_digest, &err);
2797 if (err) {
2798 goto out;
2799 }
2800 }
2801 if (visit_optional(v, "timeout", &obj->has_timeout)) {
2802 visit_type_int(v, "timeout", &obj->timeout, &err);
2803 if (err) {
2804 goto out;
2805 }
2806 }
2807
2808out:
2809 error_propagate(errp, err);
2810}
2811
2812void visit_type_BlockdevOptionsIscsi(Visitor *v, const char *name, BlockdevOptionsIscsi **obj, Error **errp)
2813{
2814 Error *err = NULL;
2815
2816 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptionsIscsi), &err);
2817 if (err) {
2818 goto out;
2819 }
2820 if (!*obj) {
2821 goto out_obj;
2822 }
2823 visit_type_BlockdevOptionsIscsi_members(v, *obj, &err);
2824 if (err) {
2825 goto out_obj;
2826 }
2827 visit_check_struct(v, &err);
2828out_obj:
2829 visit_end_struct(v, (void **)obj);
2830 if (err && visit_is_input(v)) {
2831 qapi_free_BlockdevOptionsIscsi(*obj);
2832 *obj = NULL;
2833 }
2834out:
2835 error_propagate(errp, err);
2836}
2837
2838void visit_type_BlockdevOptionsLUKS_members(Visitor *v, BlockdevOptionsLUKS *obj, Error **errp)
2839{
2840 Error *err = NULL;
2841
2842 visit_type_BlockdevOptionsGenericFormat_members(v, (BlockdevOptionsGenericFormat *)obj, &err);
2843 if (err) {
2844 goto out;
2845 }
2846 if (visit_optional(v, "key-secret", &obj->has_key_secret)) {
2847 visit_type_str(v, "key-secret", &obj->key_secret, &err);
2848 if (err) {
2849 goto out;
2850 }
2851 }
2852
2853out:
2854 error_propagate(errp, err);
2855}
2856
2857void visit_type_BlockdevOptionsLUKS(Visitor *v, const char *name, BlockdevOptionsLUKS **obj, Error **errp)
2858{
2859 Error *err = NULL;
2860
2861 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptionsLUKS), &err);
2862 if (err) {
2863 goto out;
2864 }
2865 if (!*obj) {
2866 goto out_obj;
2867 }
2868 visit_type_BlockdevOptionsLUKS_members(v, *obj, &err);
2869 if (err) {
2870 goto out_obj;
2871 }
2872 visit_check_struct(v, &err);
2873out_obj:
2874 visit_end_struct(v, (void **)obj);
2875 if (err && visit_is_input(v)) {
2876 qapi_free_BlockdevOptionsLUKS(*obj);
2877 *obj = NULL;
2878 }
2879out:
2880 error_propagate(errp, err);
2881}
2882
2883void visit_type_BlockdevOptionsNbd_members(Visitor *v, BlockdevOptionsNbd *obj, Error **errp)
2884{
2885 Error *err = NULL;
2886
2887 visit_type_SocketAddress(v, "server", &obj->server, &err);
2888 if (err) {
2889 goto out;
2890 }
2891 if (visit_optional(v, "export", &obj->has_export)) {
2892 visit_type_str(v, "export", &obj->export, &err);
2893 if (err) {
2894 goto out;
2895 }
2896 }
2897 if (visit_optional(v, "tls-creds", &obj->has_tls_creds)) {
2898 visit_type_str(v, "tls-creds", &obj->tls_creds, &err);
2899 if (err) {
2900 goto out;
2901 }
2902 }
2903
2904out:
2905 error_propagate(errp, err);
2906}
2907
2908void visit_type_BlockdevOptionsNbd(Visitor *v, const char *name, BlockdevOptionsNbd **obj, Error **errp)
2909{
2910 Error *err = NULL;
2911
2912 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptionsNbd), &err);
2913 if (err) {
2914 goto out;
2915 }
2916 if (!*obj) {
2917 goto out_obj;
2918 }
2919 visit_type_BlockdevOptionsNbd_members(v, *obj, &err);
2920 if (err) {
2921 goto out_obj;
2922 }
2923 visit_check_struct(v, &err);
2924out_obj:
2925 visit_end_struct(v, (void **)obj);
2926 if (err && visit_is_input(v)) {
2927 qapi_free_BlockdevOptionsNbd(*obj);
2928 *obj = NULL;
2929 }
2930out:
2931 error_propagate(errp, err);
2932}
2933
2934void visit_type_BlockdevOptionsNfs_members(Visitor *v, BlockdevOptionsNfs *obj, Error **errp)
2935{
2936 Error *err = NULL;
2937
2938 visit_type_NFSServer(v, "server", &obj->server, &err);
2939 if (err) {
2940 goto out;
2941 }
2942 visit_type_str(v, "path", &obj->path, &err);
2943 if (err) {
2944 goto out;
2945 }
2946 if (visit_optional(v, "user", &obj->has_user)) {
2947 visit_type_int(v, "user", &obj->user, &err);
2948 if (err) {
2949 goto out;
2950 }
2951 }
2952 if (visit_optional(v, "group", &obj->has_group)) {
2953 visit_type_int(v, "group", &obj->group, &err);
2954 if (err) {
2955 goto out;
2956 }
2957 }
2958 if (visit_optional(v, "tcp-syn-count", &obj->has_tcp_syn_count)) {
2959 visit_type_int(v, "tcp-syn-count", &obj->tcp_syn_count, &err);
2960 if (err) {
2961 goto out;
2962 }
2963 }
2964 if (visit_optional(v, "readahead-size", &obj->has_readahead_size)) {
2965 visit_type_int(v, "readahead-size", &obj->readahead_size, &err);
2966 if (err) {
2967 goto out;
2968 }
2969 }
2970 if (visit_optional(v, "page-cache-size", &obj->has_page_cache_size)) {
2971 visit_type_int(v, "page-cache-size", &obj->page_cache_size, &err);
2972 if (err) {
2973 goto out;
2974 }
2975 }
2976 if (visit_optional(v, "debug", &obj->has_debug)) {
2977 visit_type_int(v, "debug", &obj->debug, &err);
2978 if (err) {
2979 goto out;
2980 }
2981 }
2982
2983out:
2984 error_propagate(errp, err);
2985}
2986
2987void visit_type_BlockdevOptionsNfs(Visitor *v, const char *name, BlockdevOptionsNfs **obj, Error **errp)
2988{
2989 Error *err = NULL;
2990
2991 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptionsNfs), &err);
2992 if (err) {
2993 goto out;
2994 }
2995 if (!*obj) {
2996 goto out_obj;
2997 }
2998 visit_type_BlockdevOptionsNfs_members(v, *obj, &err);
2999 if (err) {
3000 goto out_obj;
3001 }
3002 visit_check_struct(v, &err);
3003out_obj:
3004 visit_end_struct(v, (void **)obj);
3005 if (err && visit_is_input(v)) {
3006 qapi_free_BlockdevOptionsNfs(*obj);
3007 *obj = NULL;
3008 }
3009out:
3010 error_propagate(errp, err);
3011}
3012
3013void visit_type_BlockdevOptionsNull_members(Visitor *v, BlockdevOptionsNull *obj, Error **errp)
3014{
3015 Error *err = NULL;
3016
3017 if (visit_optional(v, "size", &obj->has_size)) {
3018 visit_type_int(v, "size", &obj->size, &err);
3019 if (err) {
3020 goto out;
3021 }
3022 }
3023 if (visit_optional(v, "latency-ns", &obj->has_latency_ns)) {
3024 visit_type_uint64(v, "latency-ns", &obj->latency_ns, &err);
3025 if (err) {
3026 goto out;
3027 }
3028 }
3029
3030out:
3031 error_propagate(errp, err);
3032}
3033
3034void visit_type_BlockdevOptionsNull(Visitor *v, const char *name, BlockdevOptionsNull **obj, Error **errp)
3035{
3036 Error *err = NULL;
3037
3038 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptionsNull), &err);
3039 if (err) {
3040 goto out;
3041 }
3042 if (!*obj) {
3043 goto out_obj;
3044 }
3045 visit_type_BlockdevOptionsNull_members(v, *obj, &err);
3046 if (err) {
3047 goto out_obj;
3048 }
3049 visit_check_struct(v, &err);
3050out_obj:
3051 visit_end_struct(v, (void **)obj);
3052 if (err && visit_is_input(v)) {
3053 qapi_free_BlockdevOptionsNull(*obj);
3054 *obj = NULL;
3055 }
3056out:
3057 error_propagate(errp, err);
3058}
3059
3060void visit_type_BlockdevOptionsQcow_members(Visitor *v, BlockdevOptionsQcow *obj, Error **errp)
3061{
3062 Error *err = NULL;
3063
3064 visit_type_BlockdevOptionsGenericCOWFormat_members(v, (BlockdevOptionsGenericCOWFormat *)obj, &err);
3065 if (err) {
3066 goto out;
3067 }
3068 if (visit_optional(v, "encrypt", &obj->has_encrypt)) {
3069 visit_type_BlockdevQcowEncryption(v, "encrypt", &obj->encrypt, &err);
3070 if (err) {
3071 goto out;
3072 }
3073 }
3074
3075out:
3076 error_propagate(errp, err);
3077}
3078
3079void visit_type_BlockdevOptionsQcow(Visitor *v, const char *name, BlockdevOptionsQcow **obj, Error **errp)
3080{
3081 Error *err = NULL;
3082
3083 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptionsQcow), &err);
3084 if (err) {
3085 goto out;
3086 }
3087 if (!*obj) {
3088 goto out_obj;
3089 }
3090 visit_type_BlockdevOptionsQcow_members(v, *obj, &err);
3091 if (err) {
3092 goto out_obj;
3093 }
3094 visit_check_struct(v, &err);
3095out_obj:
3096 visit_end_struct(v, (void **)obj);
3097 if (err && visit_is_input(v)) {
3098 qapi_free_BlockdevOptionsQcow(*obj);
3099 *obj = NULL;
3100 }
3101out:
3102 error_propagate(errp, err);
3103}
3104
3105void visit_type_BlockdevOptionsQcow2_members(Visitor *v, BlockdevOptionsQcow2 *obj, Error **errp)
3106{
3107 Error *err = NULL;
3108
3109 visit_type_BlockdevOptionsGenericCOWFormat_members(v, (BlockdevOptionsGenericCOWFormat *)obj, &err);
3110 if (err) {
3111 goto out;
3112 }
3113 if (visit_optional(v, "lazy-refcounts", &obj->has_lazy_refcounts)) {
3114 visit_type_bool(v, "lazy-refcounts", &obj->lazy_refcounts, &err);
3115 if (err) {
3116 goto out;
3117 }
3118 }
3119 if (visit_optional(v, "pass-discard-request", &obj->has_pass_discard_request)) {
3120 visit_type_bool(v, "pass-discard-request", &obj->pass_discard_request, &err);
3121 if (err) {
3122 goto out;
3123 }
3124 }
3125 if (visit_optional(v, "pass-discard-snapshot", &obj->has_pass_discard_snapshot)) {
3126 visit_type_bool(v, "pass-discard-snapshot", &obj->pass_discard_snapshot, &err);
3127 if (err) {
3128 goto out;
3129 }
3130 }
3131 if (visit_optional(v, "pass-discard-other", &obj->has_pass_discard_other)) {
3132 visit_type_bool(v, "pass-discard-other", &obj->pass_discard_other, &err);
3133 if (err) {
3134 goto out;
3135 }
3136 }
3137 if (visit_optional(v, "overlap-check", &obj->has_overlap_check)) {
3138 visit_type_Qcow2OverlapChecks(v, "overlap-check", &obj->overlap_check, &err);
3139 if (err) {
3140 goto out;
3141 }
3142 }
3143 if (visit_optional(v, "cache-size", &obj->has_cache_size)) {
3144 visit_type_int(v, "cache-size", &obj->cache_size, &err);
3145 if (err) {
3146 goto out;
3147 }
3148 }
3149 if (visit_optional(v, "l2-cache-size", &obj->has_l2_cache_size)) {
3150 visit_type_int(v, "l2-cache-size", &obj->l2_cache_size, &err);
3151 if (err) {
3152 goto out;
3153 }
3154 }
3155 if (visit_optional(v, "refcount-cache-size", &obj->has_refcount_cache_size)) {
3156 visit_type_int(v, "refcount-cache-size", &obj->refcount_cache_size, &err);
3157 if (err) {
3158 goto out;
3159 }
3160 }
3161 if (visit_optional(v, "cache-clean-interval", &obj->has_cache_clean_interval)) {
3162 visit_type_int(v, "cache-clean-interval", &obj->cache_clean_interval, &err);
3163 if (err) {
3164 goto out;
3165 }
3166 }
3167 if (visit_optional(v, "encrypt", &obj->has_encrypt)) {
3168 visit_type_BlockdevQcow2Encryption(v, "encrypt", &obj->encrypt, &err);
3169 if (err) {
3170 goto out;
3171 }
3172 }
3173
3174out:
3175 error_propagate(errp, err);
3176}
3177
3178void visit_type_BlockdevOptionsQcow2(Visitor *v, const char *name, BlockdevOptionsQcow2 **obj, Error **errp)
3179{
3180 Error *err = NULL;
3181
3182 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptionsQcow2), &err);
3183 if (err) {
3184 goto out;
3185 }
3186 if (!*obj) {
3187 goto out_obj;
3188 }
3189 visit_type_BlockdevOptionsQcow2_members(v, *obj, &err);
3190 if (err) {
3191 goto out_obj;
3192 }
3193 visit_check_struct(v, &err);
3194out_obj:
3195 visit_end_struct(v, (void **)obj);
3196 if (err && visit_is_input(v)) {
3197 qapi_free_BlockdevOptionsQcow2(*obj);
3198 *obj = NULL;
3199 }
3200out:
3201 error_propagate(errp, err);
3202}
3203
3204void visit_type_BlockdevOptionsQuorum_members(Visitor *v, BlockdevOptionsQuorum *obj, Error **errp)
3205{
3206 Error *err = NULL;
3207
3208 if (visit_optional(v, "blkverify", &obj->has_blkverify)) {
3209 visit_type_bool(v, "blkverify", &obj->blkverify, &err);
3210 if (err) {
3211 goto out;
3212 }
3213 }
3214 visit_type_BlockdevRefList(v, "children", &obj->children, &err);
3215 if (err) {
3216 goto out;
3217 }
3218 visit_type_int(v, "vote-threshold", &obj->vote_threshold, &err);
3219 if (err) {
3220 goto out;
3221 }
3222 if (visit_optional(v, "rewrite-corrupted", &obj->has_rewrite_corrupted)) {
3223 visit_type_bool(v, "rewrite-corrupted", &obj->rewrite_corrupted, &err);
3224 if (err) {
3225 goto out;
3226 }
3227 }
3228 if (visit_optional(v, "read-pattern", &obj->has_read_pattern)) {
3229 visit_type_QuorumReadPattern(v, "read-pattern", &obj->read_pattern, &err);
3230 if (err) {
3231 goto out;
3232 }
3233 }
3234
3235out:
3236 error_propagate(errp, err);
3237}
3238
3239void visit_type_BlockdevOptionsQuorum(Visitor *v, const char *name, BlockdevOptionsQuorum **obj, Error **errp)
3240{
3241 Error *err = NULL;
3242
3243 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptionsQuorum), &err);
3244 if (err) {
3245 goto out;
3246 }
3247 if (!*obj) {
3248 goto out_obj;
3249 }
3250 visit_type_BlockdevOptionsQuorum_members(v, *obj, &err);
3251 if (err) {
3252 goto out_obj;
3253 }
3254 visit_check_struct(v, &err);
3255out_obj:
3256 visit_end_struct(v, (void **)obj);
3257 if (err && visit_is_input(v)) {
3258 qapi_free_BlockdevOptionsQuorum(*obj);
3259 *obj = NULL;
3260 }
3261out:
3262 error_propagate(errp, err);
3263}
3264
3265void visit_type_BlockdevOptionsRaw_members(Visitor *v, BlockdevOptionsRaw *obj, Error **errp)
3266{
3267 Error *err = NULL;
3268
3269 visit_type_BlockdevOptionsGenericFormat_members(v, (BlockdevOptionsGenericFormat *)obj, &err);
3270 if (err) {
3271 goto out;
3272 }
3273 if (visit_optional(v, "offset", &obj->has_offset)) {
3274 visit_type_int(v, "offset", &obj->offset, &err);
3275 if (err) {
3276 goto out;
3277 }
3278 }
3279 if (visit_optional(v, "size", &obj->has_size)) {
3280 visit_type_int(v, "size", &obj->size, &err);
3281 if (err) {
3282 goto out;
3283 }
3284 }
3285
3286out:
3287 error_propagate(errp, err);
3288}
3289
3290void visit_type_BlockdevOptionsRaw(Visitor *v, const char *name, BlockdevOptionsRaw **obj, Error **errp)
3291{
3292 Error *err = NULL;
3293
3294 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptionsRaw), &err);
3295 if (err) {
3296 goto out;
3297 }
3298 if (!*obj) {
3299 goto out_obj;
3300 }
3301 visit_type_BlockdevOptionsRaw_members(v, *obj, &err);
3302 if (err) {
3303 goto out_obj;
3304 }
3305 visit_check_struct(v, &err);
3306out_obj:
3307 visit_end_struct(v, (void **)obj);
3308 if (err && visit_is_input(v)) {
3309 qapi_free_BlockdevOptionsRaw(*obj);
3310 *obj = NULL;
3311 }
3312out:
3313 error_propagate(errp, err);
3314}
3315
3316void visit_type_BlockdevOptionsRbd_members(Visitor *v, BlockdevOptionsRbd *obj, Error **errp)
3317{
3318 Error *err = NULL;
3319
3320 visit_type_str(v, "pool", &obj->pool, &err);
3321 if (err) {
3322 goto out;
3323 }
3324 visit_type_str(v, "image", &obj->image, &err);
3325 if (err) {
3326 goto out;
3327 }
3328 if (visit_optional(v, "conf", &obj->has_conf)) {
3329 visit_type_str(v, "conf", &obj->conf, &err);
3330 if (err) {
3331 goto out;
3332 }
3333 }
3334 if (visit_optional(v, "snapshot", &obj->has_snapshot)) {
3335 visit_type_str(v, "snapshot", &obj->snapshot, &err);
3336 if (err) {
3337 goto out;
3338 }
3339 }
3340 if (visit_optional(v, "user", &obj->has_user)) {
3341 visit_type_str(v, "user", &obj->user, &err);
3342 if (err) {
3343 goto out;
3344 }
3345 }
3346 if (visit_optional(v, "server", &obj->has_server)) {
3347 visit_type_InetSocketAddressBaseList(v, "server", &obj->server, &err);
3348 if (err) {
3349 goto out;
3350 }
3351 }
3352
3353out:
3354 error_propagate(errp, err);
3355}
3356
3357void visit_type_BlockdevOptionsRbd(Visitor *v, const char *name, BlockdevOptionsRbd **obj, Error **errp)
3358{
3359 Error *err = NULL;
3360
3361 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptionsRbd), &err);
3362 if (err) {
3363 goto out;
3364 }
3365 if (!*obj) {
3366 goto out_obj;
3367 }
3368 visit_type_BlockdevOptionsRbd_members(v, *obj, &err);
3369 if (err) {
3370 goto out_obj;
3371 }
3372 visit_check_struct(v, &err);
3373out_obj:
3374 visit_end_struct(v, (void **)obj);
3375 if (err && visit_is_input(v)) {
3376 qapi_free_BlockdevOptionsRbd(*obj);
3377 *obj = NULL;
3378 }
3379out:
3380 error_propagate(errp, err);
3381}
3382
3383void visit_type_BlockdevOptionsReplication_members(Visitor *v, BlockdevOptionsReplication *obj, Error **errp)
3384{
3385 Error *err = NULL;
3386
3387 visit_type_BlockdevOptionsGenericFormat_members(v, (BlockdevOptionsGenericFormat *)obj, &err);
3388 if (err) {
3389 goto out;
3390 }
3391 visit_type_ReplicationMode(v, "mode", &obj->mode, &err);
3392 if (err) {
3393 goto out;
3394 }
3395 if (visit_optional(v, "top-id", &obj->has_top_id)) {
3396 visit_type_str(v, "top-id", &obj->top_id, &err);
3397 if (err) {
3398 goto out;
3399 }
3400 }
3401
3402out:
3403 error_propagate(errp, err);
3404}
3405
3406void visit_type_BlockdevOptionsReplication(Visitor *v, const char *name, BlockdevOptionsReplication **obj, Error **errp)
3407{
3408 Error *err = NULL;
3409
3410 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptionsReplication), &err);
3411 if (err) {
3412 goto out;
3413 }
3414 if (!*obj) {
3415 goto out_obj;
3416 }
3417 visit_type_BlockdevOptionsReplication_members(v, *obj, &err);
3418 if (err) {
3419 goto out_obj;
3420 }
3421 visit_check_struct(v, &err);
3422out_obj:
3423 visit_end_struct(v, (void **)obj);
3424 if (err && visit_is_input(v)) {
3425 qapi_free_BlockdevOptionsReplication(*obj);
3426 *obj = NULL;
3427 }
3428out:
3429 error_propagate(errp, err);
3430}
3431
3432void visit_type_BlockdevOptionsSheepdog_members(Visitor *v, BlockdevOptionsSheepdog *obj, Error **errp)
3433{
3434 Error *err = NULL;
3435
3436 visit_type_SocketAddress(v, "server", &obj->server, &err);
3437 if (err) {
3438 goto out;
3439 }
3440 visit_type_str(v, "vdi", &obj->vdi, &err);
3441 if (err) {
3442 goto out;
3443 }
3444 if (visit_optional(v, "snap-id", &obj->has_snap_id)) {
3445 visit_type_uint32(v, "snap-id", &obj->snap_id, &err);
3446 if (err) {
3447 goto out;
3448 }
3449 }
3450 if (visit_optional(v, "tag", &obj->has_tag)) {
3451 visit_type_str(v, "tag", &obj->tag, &err);
3452 if (err) {
3453 goto out;
3454 }
3455 }
3456
3457out:
3458 error_propagate(errp, err);
3459}
3460
3461void visit_type_BlockdevOptionsSheepdog(Visitor *v, const char *name, BlockdevOptionsSheepdog **obj, Error **errp)
3462{
3463 Error *err = NULL;
3464
3465 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptionsSheepdog), &err);
3466 if (err) {
3467 goto out;
3468 }
3469 if (!*obj) {
3470 goto out_obj;
3471 }
3472 visit_type_BlockdevOptionsSheepdog_members(v, *obj, &err);
3473 if (err) {
3474 goto out_obj;
3475 }
3476 visit_check_struct(v, &err);
3477out_obj:
3478 visit_end_struct(v, (void **)obj);
3479 if (err && visit_is_input(v)) {
3480 qapi_free_BlockdevOptionsSheepdog(*obj);
3481 *obj = NULL;
3482 }
3483out:
3484 error_propagate(errp, err);
3485}
3486
3487void visit_type_BlockdevOptionsSsh_members(Visitor *v, BlockdevOptionsSsh *obj, Error **errp)
3488{
3489 Error *err = NULL;
3490
3491 visit_type_InetSocketAddress(v, "server", &obj->server, &err);
3492 if (err) {
3493 goto out;
3494 }
3495 visit_type_str(v, "path", &obj->path, &err);
3496 if (err) {
3497 goto out;
3498 }
3499 if (visit_optional(v, "user", &obj->has_user)) {
3500 visit_type_str(v, "user", &obj->user, &err);
3501 if (err) {
3502 goto out;
3503 }
3504 }
3505
3506out:
3507 error_propagate(errp, err);
3508}
3509
3510void visit_type_BlockdevOptionsSsh(Visitor *v, const char *name, BlockdevOptionsSsh **obj, Error **errp)
3511{
3512 Error *err = NULL;
3513
3514 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptionsSsh), &err);
3515 if (err) {
3516 goto out;
3517 }
3518 if (!*obj) {
3519 goto out_obj;
3520 }
3521 visit_type_BlockdevOptionsSsh_members(v, *obj, &err);
3522 if (err) {
3523 goto out_obj;
3524 }
3525 visit_check_struct(v, &err);
3526out_obj:
3527 visit_end_struct(v, (void **)obj);
3528 if (err && visit_is_input(v)) {
3529 qapi_free_BlockdevOptionsSsh(*obj);
3530 *obj = NULL;
3531 }
3532out:
3533 error_propagate(errp, err);
3534}
3535
3536void visit_type_BlockdevOptionsVVFAT_members(Visitor *v, BlockdevOptionsVVFAT *obj, Error **errp)
3537{
3538 Error *err = NULL;
3539
3540 visit_type_str(v, "dir", &obj->dir, &err);
3541 if (err) {
3542 goto out;
3543 }
3544 if (visit_optional(v, "fat-type", &obj->has_fat_type)) {
3545 visit_type_int(v, "fat-type", &obj->fat_type, &err);
3546 if (err) {
3547 goto out;
3548 }
3549 }
3550 if (visit_optional(v, "floppy", &obj->has_floppy)) {
3551 visit_type_bool(v, "floppy", &obj->floppy, &err);
3552 if (err) {
3553 goto out;
3554 }
3555 }
3556 if (visit_optional(v, "label", &obj->has_label)) {
3557 visit_type_str(v, "label", &obj->label, &err);
3558 if (err) {
3559 goto out;
3560 }
3561 }
3562 if (visit_optional(v, "rw", &obj->has_rw)) {
3563 visit_type_bool(v, "rw", &obj->rw, &err);
3564 if (err) {
3565 goto out;
3566 }
3567 }
3568
3569out:
3570 error_propagate(errp, err);
3571}
3572
3573void visit_type_BlockdevOptionsVVFAT(Visitor *v, const char *name, BlockdevOptionsVVFAT **obj, Error **errp)
3574{
3575 Error *err = NULL;
3576
3577 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptionsVVFAT), &err);
3578 if (err) {
3579 goto out;
3580 }
3581 if (!*obj) {
3582 goto out_obj;
3583 }
3584 visit_type_BlockdevOptionsVVFAT_members(v, *obj, &err);
3585 if (err) {
3586 goto out_obj;
3587 }
3588 visit_check_struct(v, &err);
3589out_obj:
3590 visit_end_struct(v, (void **)obj);
3591 if (err && visit_is_input(v)) {
3592 qapi_free_BlockdevOptionsVVFAT(*obj);
3593 *obj = NULL;
3594 }
3595out:
3596 error_propagate(errp, err);
3597}
3598
3599void visit_type_BlockdevOptionsVxHS_members(Visitor *v, BlockdevOptionsVxHS *obj, Error **errp)
3600{
3601 Error *err = NULL;
3602
3603 visit_type_str(v, "vdisk-id", &obj->vdisk_id, &err);
3604 if (err) {
3605 goto out;
3606 }
3607 visit_type_InetSocketAddressBase(v, "server", &obj->server, &err);
3608 if (err) {
3609 goto out;
3610 }
3611 if (visit_optional(v, "tls-creds", &obj->has_tls_creds)) {
3612 visit_type_str(v, "tls-creds", &obj->tls_creds, &err);
3613 if (err) {
3614 goto out;
3615 }
3616 }
3617
3618out:
3619 error_propagate(errp, err);
3620}
3621
3622void visit_type_BlockdevOptionsVxHS(Visitor *v, const char *name, BlockdevOptionsVxHS **obj, Error **errp)
3623{
3624 Error *err = NULL;
3625
3626 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptionsVxHS), &err);
3627 if (err) {
3628 goto out;
3629 }
3630 if (!*obj) {
3631 goto out_obj;
3632 }
3633 visit_type_BlockdevOptionsVxHS_members(v, *obj, &err);
3634 if (err) {
3635 goto out_obj;
3636 }
3637 visit_check_struct(v, &err);
3638out_obj:
3639 visit_end_struct(v, (void **)obj);
3640 if (err && visit_is_input(v)) {
3641 qapi_free_BlockdevOptionsVxHS(*obj);
3642 *obj = NULL;
3643 }
3644out:
3645 error_propagate(errp, err);
3646}
3647
3648void visit_type_BlockdevQcow2Encryption_members(Visitor *v, BlockdevQcow2Encryption *obj, Error **errp)
3649{
3650 Error *err = NULL;
3651
3652 visit_type_q_obj_BlockdevQcow2Encryption_base_members(v, (q_obj_BlockdevQcow2Encryption_base *)obj, &err);
3653 if (err) {
3654 goto out;
3655 }
3656 switch (obj->format) {
3657 case BLOCKDEV_QCOW2_ENCRYPTION_FORMAT_AES:
3658 visit_type_QCryptoBlockOptionsQCow_members(v, &obj->u.aes, &err);
3659 break;
3660 case BLOCKDEV_QCOW2_ENCRYPTION_FORMAT_LUKS:
3661 visit_type_QCryptoBlockOptionsLUKS_members(v, &obj->u.luks, &err);
3662 break;
3663 default:
3664 abort();
3665 }
3666
3667out:
3668 error_propagate(errp, err);
3669}
3670
3671void visit_type_BlockdevQcow2Encryption(Visitor *v, const char *name, BlockdevQcow2Encryption **obj, Error **errp)
3672{
3673 Error *err = NULL;
3674
3675 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevQcow2Encryption), &err);
3676 if (err) {
3677 goto out;
3678 }
3679 if (!*obj) {
3680 goto out_obj;
3681 }
3682 visit_type_BlockdevQcow2Encryption_members(v, *obj, &err);
3683 if (err) {
3684 goto out_obj;
3685 }
3686 visit_check_struct(v, &err);
3687out_obj:
3688 visit_end_struct(v, (void **)obj);
3689 if (err && visit_is_input(v)) {
3690 qapi_free_BlockdevQcow2Encryption(*obj);
3691 *obj = NULL;
3692 }
3693out:
3694 error_propagate(errp, err);
3695}
3696
3697void visit_type_BlockdevQcow2EncryptionFormat(Visitor *v, const char *name, BlockdevQcow2EncryptionFormat *obj, Error **errp)
3698{
3699 int value = *obj;
3700 visit_type_enum(v, name, &value, BlockdevQcow2EncryptionFormat_lookup, errp);
3701 *obj = value;
3702}
3703
3704void visit_type_BlockdevQcowEncryption_members(Visitor *v, BlockdevQcowEncryption *obj, Error **errp)
3705{
3706 Error *err = NULL;
3707
3708 visit_type_q_obj_BlockdevQcowEncryption_base_members(v, (q_obj_BlockdevQcowEncryption_base *)obj, &err);
3709 if (err) {
3710 goto out;
3711 }
3712 switch (obj->format) {
3713 case BLOCKDEV_QCOW_ENCRYPTION_FORMAT_AES:
3714 visit_type_QCryptoBlockOptionsQCow_members(v, &obj->u.aes, &err);
3715 break;
3716 default:
3717 abort();
3718 }
3719
3720out:
3721 error_propagate(errp, err);
3722}
3723
3724void visit_type_BlockdevQcowEncryption(Visitor *v, const char *name, BlockdevQcowEncryption **obj, Error **errp)
3725{
3726 Error *err = NULL;
3727
3728 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevQcowEncryption), &err);
3729 if (err) {
3730 goto out;
3731 }
3732 if (!*obj) {
3733 goto out_obj;
3734 }
3735 visit_type_BlockdevQcowEncryption_members(v, *obj, &err);
3736 if (err) {
3737 goto out_obj;
3738 }
3739 visit_check_struct(v, &err);
3740out_obj:
3741 visit_end_struct(v, (void **)obj);
3742 if (err && visit_is_input(v)) {
3743 qapi_free_BlockdevQcowEncryption(*obj);
3744 *obj = NULL;
3745 }
3746out:
3747 error_propagate(errp, err);
3748}
3749
3750void visit_type_BlockdevQcowEncryptionFormat(Visitor *v, const char *name, BlockdevQcowEncryptionFormat *obj, Error **errp)
3751{
3752 int value = *obj;
3753 visit_type_enum(v, name, &value, BlockdevQcowEncryptionFormat_lookup, errp);
3754 *obj = value;
3755}
3756
3757void visit_type_BlockdevRef(Visitor *v, const char *name, BlockdevRef **obj, Error **errp)
3758{
3759 Error *err = NULL;
3760
3761 visit_start_alternate(v, name, (GenericAlternate **)obj, sizeof(**obj),
3762 &err);
3763 if (err) {
3764 goto out;
3765 }
3766 if (!*obj) {
3767 goto out_obj;
3768 }
3769 switch ((*obj)->type) {
3770 case QTYPE_QDICT:
3771 visit_start_struct(v, name, NULL, 0, &err);
3772 if (err) {
3773 break;
3774 }
3775 visit_type_BlockdevOptions_members(v, &(*obj)->u.definition, &err);
3776 if (!err) {
3777 visit_check_struct(v, &err);
3778 }
3779 visit_end_struct(v, NULL);
3780 break;
3781 case QTYPE_QSTRING:
3782 visit_type_str(v, name, &(*obj)->u.reference, &err);
3783 break;
3784 case QTYPE_NONE:
3785 abort();
3786 default:
3787 error_setg(&err, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
3788 "BlockdevRef");
3789 }
3790out_obj:
3791 visit_end_alternate(v, (void **)obj);
3792 if (err && visit_is_input(v)) {
3793 qapi_free_BlockdevRef(*obj);
3794 *obj = NULL;
3795 }
3796out:
3797 error_propagate(errp, err);
3798}
3799
3800void visit_type_BlockdevRefList(Visitor *v, const char *name, BlockdevRefList **obj, Error **errp)
3801{
3802 Error *err = NULL;
3803 BlockdevRefList *tail;
3804 size_t size = sizeof(**obj);
3805
3806 visit_start_list(v, name, (GenericList **)obj, size, &err);
3807 if (err) {
3808 goto out;
3809 }
3810
3811 for (tail = *obj; tail;
3812 tail = (BlockdevRefList *)visit_next_list(v, (GenericList *)tail, size)) {
3813 visit_type_BlockdevRef(v, NULL, &tail->value, &err);
3814 if (err) {
3815 break;
3816 }
3817 }
3818
3819 if (!err) {
3820 visit_check_list(v, &err);
3821 }
3822 visit_end_list(v, (void **)obj);
3823 if (err && visit_is_input(v)) {
3824 qapi_free_BlockdevRefList(*obj);
3825 *obj = NULL;
3826 }
3827out:
3828 error_propagate(errp, err);
3829}
3830
3831void visit_type_BlockdevRefOrNull(Visitor *v, const char *name, BlockdevRefOrNull **obj, Error **errp)
3832{
3833 Error *err = NULL;
3834
3835 visit_start_alternate(v, name, (GenericAlternate **)obj, sizeof(**obj),
3836 &err);
3837 if (err) {
3838 goto out;
3839 }
3840 if (!*obj) {
3841 goto out_obj;
3842 }
3843 switch ((*obj)->type) {
3844 case QTYPE_QDICT:
3845 visit_start_struct(v, name, NULL, 0, &err);
3846 if (err) {
3847 break;
3848 }
3849 visit_type_BlockdevOptions_members(v, &(*obj)->u.definition, &err);
3850 if (!err) {
3851 visit_check_struct(v, &err);
3852 }
3853 visit_end_struct(v, NULL);
3854 break;
3855 case QTYPE_QSTRING:
3856 visit_type_str(v, name, &(*obj)->u.reference, &err);
3857 break;
3858 case QTYPE_QNULL:
3859 visit_type_null(v, name, &(*obj)->u.null, &err);
3860 break;
3861 case QTYPE_NONE:
3862 abort();
3863 default:
3864 error_setg(&err, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
3865 "BlockdevRefOrNull");
3866 }
3867out_obj:
3868 visit_end_alternate(v, (void **)obj);
3869 if (err && visit_is_input(v)) {
3870 qapi_free_BlockdevRefOrNull(*obj);
3871 *obj = NULL;
3872 }
3873out:
3874 error_propagate(errp, err);
3875}
3876
3877void visit_type_BlockdevSnapshot_members(Visitor *v, BlockdevSnapshot *obj, Error **errp)
3878{
3879 Error *err = NULL;
3880
3881 visit_type_str(v, "node", &obj->node, &err);
3882 if (err) {
3883 goto out;
3884 }
3885 visit_type_str(v, "overlay", &obj->overlay, &err);
3886 if (err) {
3887 goto out;
3888 }
3889
3890out:
3891 error_propagate(errp, err);
3892}
3893
3894void visit_type_BlockdevSnapshot(Visitor *v, const char *name, BlockdevSnapshot **obj, Error **errp)
3895{
3896 Error *err = NULL;
3897
3898 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevSnapshot), &err);
3899 if (err) {
3900 goto out;
3901 }
3902 if (!*obj) {
3903 goto out_obj;
3904 }
3905 visit_type_BlockdevSnapshot_members(v, *obj, &err);
3906 if (err) {
3907 goto out_obj;
3908 }
3909 visit_check_struct(v, &err);
3910out_obj:
3911 visit_end_struct(v, (void **)obj);
3912 if (err && visit_is_input(v)) {
3913 qapi_free_BlockdevSnapshot(*obj);
3914 *obj = NULL;
3915 }
3916out:
3917 error_propagate(errp, err);
3918}
3919
3920void visit_type_BlockdevSnapshotInternal_members(Visitor *v, BlockdevSnapshotInternal *obj, Error **errp)
3921{
3922 Error *err = NULL;
3923
3924 visit_type_str(v, "device", &obj->device, &err);
3925 if (err) {
3926 goto out;
3927 }
3928 visit_type_str(v, "name", &obj->name, &err);
3929 if (err) {
3930 goto out;
3931 }
3932
3933out:
3934 error_propagate(errp, err);
3935}
3936
3937void visit_type_BlockdevSnapshotInternal(Visitor *v, const char *name, BlockdevSnapshotInternal **obj, Error **errp)
3938{
3939 Error *err = NULL;
3940
3941 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevSnapshotInternal), &err);
3942 if (err) {
3943 goto out;
3944 }
3945 if (!*obj) {
3946 goto out_obj;
3947 }
3948 visit_type_BlockdevSnapshotInternal_members(v, *obj, &err);
3949 if (err) {
3950 goto out_obj;
3951 }
3952 visit_check_struct(v, &err);
3953out_obj:
3954 visit_end_struct(v, (void **)obj);
3955 if (err && visit_is_input(v)) {
3956 qapi_free_BlockdevSnapshotInternal(*obj);
3957 *obj = NULL;
3958 }
3959out:
3960 error_propagate(errp, err);
3961}
3962
3963void visit_type_BlockdevSnapshotSync_members(Visitor *v, BlockdevSnapshotSync *obj, Error **errp)
3964{
3965 Error *err = NULL;
3966
3967 if (visit_optional(v, "device", &obj->has_device)) {
3968 visit_type_str(v, "device", &obj->device, &err);
3969 if (err) {
3970 goto out;
3971 }
3972 }
3973 if (visit_optional(v, "node-name", &obj->has_node_name)) {
3974 visit_type_str(v, "node-name", &obj->node_name, &err);
3975 if (err) {
3976 goto out;
3977 }
3978 }
3979 visit_type_str(v, "snapshot-file", &obj->snapshot_file, &err);
3980 if (err) {
3981 goto out;
3982 }
3983 if (visit_optional(v, "snapshot-node-name", &obj->has_snapshot_node_name)) {
3984 visit_type_str(v, "snapshot-node-name", &obj->snapshot_node_name, &err);
3985 if (err) {
3986 goto out;
3987 }
3988 }
3989 if (visit_optional(v, "format", &obj->has_format)) {
3990 visit_type_str(v, "format", &obj->format, &err);
3991 if (err) {
3992 goto out;
3993 }
3994 }
3995 if (visit_optional(v, "mode", &obj->has_mode)) {
3996 visit_type_NewImageMode(v, "mode", &obj->mode, &err);
3997 if (err) {
3998 goto out;
3999 }
4000 }
4001
4002out:
4003 error_propagate(errp, err);
4004}
4005
4006void visit_type_BlockdevSnapshotSync(Visitor *v, const char *name, BlockdevSnapshotSync **obj, Error **errp)
4007{
4008 Error *err = NULL;
4009
4010 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevSnapshotSync), &err);
4011 if (err) {
4012 goto out;
4013 }
4014 if (!*obj) {
4015 goto out_obj;
4016 }
4017 visit_type_BlockdevSnapshotSync_members(v, *obj, &err);
4018 if (err) {
4019 goto out_obj;
4020 }
4021 visit_check_struct(v, &err);
4022out_obj:
4023 visit_end_struct(v, (void **)obj);
4024 if (err && visit_is_input(v)) {
4025 qapi_free_BlockdevSnapshotSync(*obj);
4026 *obj = NULL;
4027 }
4028out:
4029 error_propagate(errp, err);
4030}
4031
4032void visit_type_COLOMessage(Visitor *v, const char *name, COLOMessage *obj, Error **errp)
4033{
4034 int value = *obj;
4035 visit_type_enum(v, name, &value, COLOMessage_lookup, errp);
4036 *obj = value;
4037}
4038
4039void visit_type_COLOMode(Visitor *v, const char *name, COLOMode *obj, Error **errp)
4040{
4041 int value = *obj;
4042 visit_type_enum(v, name, &value, COLOMode_lookup, errp);
4043 *obj = value;
4044}
4045
4046void visit_type_ChardevBackend_members(Visitor *v, ChardevBackend *obj, Error **errp)
4047{
4048 Error *err = NULL;
4049
4050 visit_type_ChardevBackendKind(v, "type", &obj->type, &err);
4051 if (err) {
4052 goto out;
4053 }
4054 switch (obj->type) {
4055 case CHARDEV_BACKEND_KIND_FILE:
4056 visit_type_q_obj_ChardevFile_wrapper_members(v, &obj->u.file, &err);
4057 break;
4058 case CHARDEV_BACKEND_KIND_SERIAL:
4059 visit_type_q_obj_ChardevHostdev_wrapper_members(v, &obj->u.serial, &err);
4060 break;
4061 case CHARDEV_BACKEND_KIND_PARALLEL:
4062 visit_type_q_obj_ChardevHostdev_wrapper_members(v, &obj->u.parallel, &err);
4063 break;
4064 case CHARDEV_BACKEND_KIND_PIPE:
4065 visit_type_q_obj_ChardevHostdev_wrapper_members(v, &obj->u.pipe, &err);
4066 break;
4067 case CHARDEV_BACKEND_KIND_SOCKET:
4068 visit_type_q_obj_ChardevSocket_wrapper_members(v, &obj->u.socket, &err);
4069 break;
4070 case CHARDEV_BACKEND_KIND_UDP:
4071 visit_type_q_obj_ChardevUdp_wrapper_members(v, &obj->u.udp, &err);
4072 break;
4073 case CHARDEV_BACKEND_KIND_PTY:
4074 visit_type_q_obj_ChardevCommon_wrapper_members(v, &obj->u.pty, &err);
4075 break;
4076 case CHARDEV_BACKEND_KIND_NULL:
4077 visit_type_q_obj_ChardevCommon_wrapper_members(v, &obj->u.null, &err);
4078 break;
4079 case CHARDEV_BACKEND_KIND_MUX:
4080 visit_type_q_obj_ChardevMux_wrapper_members(v, &obj->u.mux, &err);
4081 break;
4082 case CHARDEV_BACKEND_KIND_MSMOUSE:
4083 visit_type_q_obj_ChardevCommon_wrapper_members(v, &obj->u.msmouse, &err);
4084 break;
4085 case CHARDEV_BACKEND_KIND_WCTABLET:
4086 visit_type_q_obj_ChardevCommon_wrapper_members(v, &obj->u.wctablet, &err);
4087 break;
4088 case CHARDEV_BACKEND_KIND_BRAILLE:
4089 visit_type_q_obj_ChardevCommon_wrapper_members(v, &obj->u.braille, &err);
4090 break;
4091 case CHARDEV_BACKEND_KIND_TESTDEV:
4092 visit_type_q_obj_ChardevCommon_wrapper_members(v, &obj->u.testdev, &err);
4093 break;
4094 case CHARDEV_BACKEND_KIND_STDIO:
4095 visit_type_q_obj_ChardevStdio_wrapper_members(v, &obj->u.stdio, &err);
4096 break;
4097 case CHARDEV_BACKEND_KIND_CONSOLE:
4098 visit_type_q_obj_ChardevCommon_wrapper_members(v, &obj->u.console, &err);
4099 break;
4100 case CHARDEV_BACKEND_KIND_SPICEVMC:
4101 visit_type_q_obj_ChardevSpiceChannel_wrapper_members(v, &obj->u.spicevmc, &err);
4102 break;
4103 case CHARDEV_BACKEND_KIND_SPICEPORT:
4104 visit_type_q_obj_ChardevSpicePort_wrapper_members(v, &obj->u.spiceport, &err);
4105 break;
4106 case CHARDEV_BACKEND_KIND_VC:
4107 visit_type_q_obj_ChardevVC_wrapper_members(v, &obj->u.vc, &err);
4108 break;
4109 case CHARDEV_BACKEND_KIND_RINGBUF:
4110 visit_type_q_obj_ChardevRingbuf_wrapper_members(v, &obj->u.ringbuf, &err);
4111 break;
4112 case CHARDEV_BACKEND_KIND_MEMORY:
4113 visit_type_q_obj_ChardevRingbuf_wrapper_members(v, &obj->u.memory, &err);
4114 break;
4115 default:
4116 abort();
4117 }
4118
4119out:
4120 error_propagate(errp, err);
4121}
4122
4123void visit_type_ChardevBackend(Visitor *v, const char *name, ChardevBackend **obj, Error **errp)
4124{
4125 Error *err = NULL;
4126
4127 visit_start_struct(v, name, (void **)obj, sizeof(ChardevBackend), &err);
4128 if (err) {
4129 goto out;
4130 }
4131 if (!*obj) {
4132 goto out_obj;
4133 }
4134 visit_type_ChardevBackend_members(v, *obj, &err);
4135 if (err) {
4136 goto out_obj;
4137 }
4138 visit_check_struct(v, &err);
4139out_obj:
4140 visit_end_struct(v, (void **)obj);
4141 if (err && visit_is_input(v)) {
4142 qapi_free_ChardevBackend(*obj);
4143 *obj = NULL;
4144 }
4145out:
4146 error_propagate(errp, err);
4147}
4148
4149void visit_type_ChardevBackendInfo_members(Visitor *v, ChardevBackendInfo *obj, Error **errp)
4150{
4151 Error *err = NULL;
4152
4153 visit_type_str(v, "name", &obj->name, &err);
4154 if (err) {
4155 goto out;
4156 }
4157
4158out:
4159 error_propagate(errp, err);
4160}
4161
4162void visit_type_ChardevBackendInfo(Visitor *v, const char *name, ChardevBackendInfo **obj, Error **errp)
4163{
4164 Error *err = NULL;
4165
4166 visit_start_struct(v, name, (void **)obj, sizeof(ChardevBackendInfo), &err);
4167 if (err) {
4168 goto out;
4169 }
4170 if (!*obj) {
4171 goto out_obj;
4172 }
4173 visit_type_ChardevBackendInfo_members(v, *obj, &err);
4174 if (err) {
4175 goto out_obj;
4176 }
4177 visit_check_struct(v, &err);
4178out_obj:
4179 visit_end_struct(v, (void **)obj);
4180 if (err && visit_is_input(v)) {
4181 qapi_free_ChardevBackendInfo(*obj);
4182 *obj = NULL;
4183 }
4184out:
4185 error_propagate(errp, err);
4186}
4187
4188void visit_type_ChardevBackendInfoList(Visitor *v, const char *name, ChardevBackendInfoList **obj, Error **errp)
4189{
4190 Error *err = NULL;
4191 ChardevBackendInfoList *tail;
4192 size_t size = sizeof(**obj);
4193
4194 visit_start_list(v, name, (GenericList **)obj, size, &err);
4195 if (err) {
4196 goto out;
4197 }
4198
4199 for (tail = *obj; tail;
4200 tail = (ChardevBackendInfoList *)visit_next_list(v, (GenericList *)tail, size)) {
4201 visit_type_ChardevBackendInfo(v, NULL, &tail->value, &err);
4202 if (err) {
4203 break;
4204 }
4205 }
4206
4207 if (!err) {
4208 visit_check_list(v, &err);
4209 }
4210 visit_end_list(v, (void **)obj);
4211 if (err && visit_is_input(v)) {
4212 qapi_free_ChardevBackendInfoList(*obj);
4213 *obj = NULL;
4214 }
4215out:
4216 error_propagate(errp, err);
4217}
4218
4219void visit_type_ChardevBackendKind(Visitor *v, const char *name, ChardevBackendKind *obj, Error **errp)
4220{
4221 int value = *obj;
4222 visit_type_enum(v, name, &value, ChardevBackendKind_lookup, errp);
4223 *obj = value;
4224}
4225
4226void visit_type_ChardevCommon_members(Visitor *v, ChardevCommon *obj, Error **errp)
4227{
4228 Error *err = NULL;
4229
4230 if (visit_optional(v, "logfile", &obj->has_logfile)) {
4231 visit_type_str(v, "logfile", &obj->logfile, &err);
4232 if (err) {
4233 goto out;
4234 }
4235 }
4236 if (visit_optional(v, "logappend", &obj->has_logappend)) {
4237 visit_type_bool(v, "logappend", &obj->logappend, &err);
4238 if (err) {
4239 goto out;
4240 }
4241 }
4242
4243out:
4244 error_propagate(errp, err);
4245}
4246
4247void visit_type_ChardevCommon(Visitor *v, const char *name, ChardevCommon **obj, Error **errp)
4248{
4249 Error *err = NULL;
4250
4251 visit_start_struct(v, name, (void **)obj, sizeof(ChardevCommon), &err);
4252 if (err) {
4253 goto out;
4254 }
4255 if (!*obj) {
4256 goto out_obj;
4257 }
4258 visit_type_ChardevCommon_members(v, *obj, &err);
4259 if (err) {
4260 goto out_obj;
4261 }
4262 visit_check_struct(v, &err);
4263out_obj:
4264 visit_end_struct(v, (void **)obj);
4265 if (err && visit_is_input(v)) {
4266 qapi_free_ChardevCommon(*obj);
4267 *obj = NULL;
4268 }
4269out:
4270 error_propagate(errp, err);
4271}
4272
4273void visit_type_ChardevFile_members(Visitor *v, ChardevFile *obj, Error **errp)
4274{
4275 Error *err = NULL;
4276
4277 visit_type_ChardevCommon_members(v, (ChardevCommon *)obj, &err);
4278 if (err) {
4279 goto out;
4280 }
4281 if (visit_optional(v, "in", &obj->has_in)) {
4282 visit_type_str(v, "in", &obj->in, &err);
4283 if (err) {
4284 goto out;
4285 }
4286 }
4287 visit_type_str(v, "out", &obj->out, &err);
4288 if (err) {
4289 goto out;
4290 }
4291 if (visit_optional(v, "append", &obj->has_append)) {
4292 visit_type_bool(v, "append", &obj->append, &err);
4293 if (err) {
4294 goto out;
4295 }
4296 }
4297
4298out:
4299 error_propagate(errp, err);
4300}
4301
4302void visit_type_ChardevFile(Visitor *v, const char *name, ChardevFile **obj, Error **errp)
4303{
4304 Error *err = NULL;
4305
4306 visit_start_struct(v, name, (void **)obj, sizeof(ChardevFile), &err);
4307 if (err) {
4308 goto out;
4309 }
4310 if (!*obj) {
4311 goto out_obj;
4312 }
4313 visit_type_ChardevFile_members(v, *obj, &err);
4314 if (err) {
4315 goto out_obj;
4316 }
4317 visit_check_struct(v, &err);
4318out_obj:
4319 visit_end_struct(v, (void **)obj);
4320 if (err && visit_is_input(v)) {
4321 qapi_free_ChardevFile(*obj);
4322 *obj = NULL;
4323 }
4324out:
4325 error_propagate(errp, err);
4326}
4327
4328void visit_type_ChardevHostdev_members(Visitor *v, ChardevHostdev *obj, Error **errp)
4329{
4330 Error *err = NULL;
4331
4332 visit_type_ChardevCommon_members(v, (ChardevCommon *)obj, &err);
4333 if (err) {
4334 goto out;
4335 }
4336 visit_type_str(v, "device", &obj->device, &err);
4337 if (err) {
4338 goto out;
4339 }
4340
4341out:
4342 error_propagate(errp, err);
4343}
4344
4345void visit_type_ChardevHostdev(Visitor *v, const char *name, ChardevHostdev **obj, Error **errp)
4346{
4347 Error *err = NULL;
4348
4349 visit_start_struct(v, name, (void **)obj, sizeof(ChardevHostdev), &err);
4350 if (err) {
4351 goto out;
4352 }
4353 if (!*obj) {
4354 goto out_obj;
4355 }
4356 visit_type_ChardevHostdev_members(v, *obj, &err);
4357 if (err) {
4358 goto out_obj;
4359 }
4360 visit_check_struct(v, &err);
4361out_obj:
4362 visit_end_struct(v, (void **)obj);
4363 if (err && visit_is_input(v)) {
4364 qapi_free_ChardevHostdev(*obj);
4365 *obj = NULL;
4366 }
4367out:
4368 error_propagate(errp, err);
4369}
4370
4371void visit_type_ChardevInfo_members(Visitor *v, ChardevInfo *obj, Error **errp)
4372{
4373 Error *err = NULL;
4374
4375 visit_type_str(v, "label", &obj->label, &err);
4376 if (err) {
4377 goto out;
4378 }
4379 visit_type_str(v, "filename", &obj->filename, &err);
4380 if (err) {
4381 goto out;
4382 }
4383 visit_type_bool(v, "frontend-open", &obj->frontend_open, &err);
4384 if (err) {
4385 goto out;
4386 }
4387
4388out:
4389 error_propagate(errp, err);
4390}
4391
4392void visit_type_ChardevInfo(Visitor *v, const char *name, ChardevInfo **obj, Error **errp)
4393{
4394 Error *err = NULL;
4395
4396 visit_start_struct(v, name, (void **)obj, sizeof(ChardevInfo), &err);
4397 if (err) {
4398 goto out;
4399 }
4400 if (!*obj) {
4401 goto out_obj;
4402 }
4403 visit_type_ChardevInfo_members(v, *obj, &err);
4404 if (err) {
4405 goto out_obj;
4406 }
4407 visit_check_struct(v, &err);
4408out_obj:
4409 visit_end_struct(v, (void **)obj);
4410 if (err && visit_is_input(v)) {
4411 qapi_free_ChardevInfo(*obj);
4412 *obj = NULL;
4413 }
4414out:
4415 error_propagate(errp, err);
4416}
4417
4418void visit_type_ChardevInfoList(Visitor *v, const char *name, ChardevInfoList **obj, Error **errp)
4419{
4420 Error *err = NULL;
4421 ChardevInfoList *tail;
4422 size_t size = sizeof(**obj);
4423
4424 visit_start_list(v, name, (GenericList **)obj, size, &err);
4425 if (err) {
4426 goto out;
4427 }
4428
4429 for (tail = *obj; tail;
4430 tail = (ChardevInfoList *)visit_next_list(v, (GenericList *)tail, size)) {
4431 visit_type_ChardevInfo(v, NULL, &tail->value, &err);
4432 if (err) {
4433 break;
4434 }
4435 }
4436
4437 if (!err) {
4438 visit_check_list(v, &err);
4439 }
4440 visit_end_list(v, (void **)obj);
4441 if (err && visit_is_input(v)) {
4442 qapi_free_ChardevInfoList(*obj);
4443 *obj = NULL;
4444 }
4445out:
4446 error_propagate(errp, err);
4447}
4448
4449void visit_type_ChardevMux_members(Visitor *v, ChardevMux *obj, Error **errp)
4450{
4451 Error *err = NULL;
4452
4453 visit_type_ChardevCommon_members(v, (ChardevCommon *)obj, &err);
4454 if (err) {
4455 goto out;
4456 }
4457 visit_type_str(v, "chardev", &obj->chardev, &err);
4458 if (err) {
4459 goto out;
4460 }
4461
4462out:
4463 error_propagate(errp, err);
4464}
4465
4466void visit_type_ChardevMux(Visitor *v, const char *name, ChardevMux **obj, Error **errp)
4467{
4468 Error *err = NULL;
4469
4470 visit_start_struct(v, name, (void **)obj, sizeof(ChardevMux), &err);
4471 if (err) {
4472 goto out;
4473 }
4474 if (!*obj) {
4475 goto out_obj;
4476 }
4477 visit_type_ChardevMux_members(v, *obj, &err);
4478 if (err) {
4479 goto out_obj;
4480 }
4481 visit_check_struct(v, &err);
4482out_obj:
4483 visit_end_struct(v, (void **)obj);
4484 if (err && visit_is_input(v)) {
4485 qapi_free_ChardevMux(*obj);
4486 *obj = NULL;
4487 }
4488out:
4489 error_propagate(errp, err);
4490}
4491
4492void visit_type_ChardevReturn_members(Visitor *v, ChardevReturn *obj, Error **errp)
4493{
4494 Error *err = NULL;
4495
4496 if (visit_optional(v, "pty", &obj->has_pty)) {
4497 visit_type_str(v, "pty", &obj->pty, &err);
4498 if (err) {
4499 goto out;
4500 }
4501 }
4502
4503out:
4504 error_propagate(errp, err);
4505}
4506
4507void visit_type_ChardevReturn(Visitor *v, const char *name, ChardevReturn **obj, Error **errp)
4508{
4509 Error *err = NULL;
4510
4511 visit_start_struct(v, name, (void **)obj, sizeof(ChardevReturn), &err);
4512 if (err) {
4513 goto out;
4514 }
4515 if (!*obj) {
4516 goto out_obj;
4517 }
4518 visit_type_ChardevReturn_members(v, *obj, &err);
4519 if (err) {
4520 goto out_obj;
4521 }
4522 visit_check_struct(v, &err);
4523out_obj:
4524 visit_end_struct(v, (void **)obj);
4525 if (err && visit_is_input(v)) {
4526 qapi_free_ChardevReturn(*obj);
4527 *obj = NULL;
4528 }
4529out:
4530 error_propagate(errp, err);
4531}
4532
4533void visit_type_ChardevRingbuf_members(Visitor *v, ChardevRingbuf *obj, Error **errp)
4534{
4535 Error *err = NULL;
4536
4537 visit_type_ChardevCommon_members(v, (ChardevCommon *)obj, &err);
4538 if (err) {
4539 goto out;
4540 }
4541 if (visit_optional(v, "size", &obj->has_size)) {
4542 visit_type_int(v, "size", &obj->size, &err);
4543 if (err) {
4544 goto out;
4545 }
4546 }
4547
4548out:
4549 error_propagate(errp, err);
4550}
4551
4552void visit_type_ChardevRingbuf(Visitor *v, const char *name, ChardevRingbuf **obj, Error **errp)
4553{
4554 Error *err = NULL;
4555
4556 visit_start_struct(v, name, (void **)obj, sizeof(ChardevRingbuf), &err);
4557 if (err) {
4558 goto out;
4559 }
4560 if (!*obj) {
4561 goto out_obj;
4562 }
4563 visit_type_ChardevRingbuf_members(v, *obj, &err);
4564 if (err) {
4565 goto out_obj;
4566 }
4567 visit_check_struct(v, &err);
4568out_obj:
4569 visit_end_struct(v, (void **)obj);
4570 if (err && visit_is_input(v)) {
4571 qapi_free_ChardevRingbuf(*obj);
4572 *obj = NULL;
4573 }
4574out:
4575 error_propagate(errp, err);
4576}
4577
4578void visit_type_ChardevSocket_members(Visitor *v, ChardevSocket *obj, Error **errp)
4579{
4580 Error *err = NULL;
4581
4582 visit_type_ChardevCommon_members(v, (ChardevCommon *)obj, &err);
4583 if (err) {
4584 goto out;
4585 }
4586 visit_type_SocketAddressLegacy(v, "addr", &obj->addr, &err);
4587 if (err) {
4588 goto out;
4589 }
4590 if (visit_optional(v, "tls-creds", &obj->has_tls_creds)) {
4591 visit_type_str(v, "tls-creds", &obj->tls_creds, &err);
4592 if (err) {
4593 goto out;
4594 }
4595 }
4596 if (visit_optional(v, "server", &obj->has_server)) {
4597 visit_type_bool(v, "server", &obj->server, &err);
4598 if (err) {
4599 goto out;
4600 }
4601 }
4602 if (visit_optional(v, "wait", &obj->has_wait)) {
4603 visit_type_bool(v, "wait", &obj->wait, &err);
4604 if (err) {
4605 goto out;
4606 }
4607 }
4608 if (visit_optional(v, "nodelay", &obj->has_nodelay)) {
4609 visit_type_bool(v, "nodelay", &obj->nodelay, &err);
4610 if (err) {
4611 goto out;
4612 }
4613 }
4614 if (visit_optional(v, "telnet", &obj->has_telnet)) {
4615 visit_type_bool(v, "telnet", &obj->telnet, &err);
4616 if (err) {
4617 goto out;
4618 }
4619 }
4620 if (visit_optional(v, "tn3270", &obj->has_tn3270)) {
4621 visit_type_bool(v, "tn3270", &obj->tn3270, &err);
4622 if (err) {
4623 goto out;
4624 }
4625 }
4626 if (visit_optional(v, "reconnect", &obj->has_reconnect)) {
4627 visit_type_int(v, "reconnect", &obj->reconnect, &err);
4628 if (err) {
4629 goto out;
4630 }
4631 }
4632
4633out:
4634 error_propagate(errp, err);
4635}
4636
4637void visit_type_ChardevSocket(Visitor *v, const char *name, ChardevSocket **obj, Error **errp)
4638{
4639 Error *err = NULL;
4640
4641 visit_start_struct(v, name, (void **)obj, sizeof(ChardevSocket), &err);
4642 if (err) {
4643 goto out;
4644 }
4645 if (!*obj) {
4646 goto out_obj;
4647 }
4648 visit_type_ChardevSocket_members(v, *obj, &err);
4649 if (err) {
4650 goto out_obj;
4651 }
4652 visit_check_struct(v, &err);
4653out_obj:
4654 visit_end_struct(v, (void **)obj);
4655 if (err && visit_is_input(v)) {
4656 qapi_free_ChardevSocket(*obj);
4657 *obj = NULL;
4658 }
4659out:
4660 error_propagate(errp, err);
4661}
4662
4663void visit_type_ChardevSpiceChannel_members(Visitor *v, ChardevSpiceChannel *obj, Error **errp)
4664{
4665 Error *err = NULL;
4666
4667 visit_type_ChardevCommon_members(v, (ChardevCommon *)obj, &err);
4668 if (err) {
4669 goto out;
4670 }
4671 visit_type_str(v, "type", &obj->type, &err);
4672 if (err) {
4673 goto out;
4674 }
4675
4676out:
4677 error_propagate(errp, err);
4678}
4679
4680void visit_type_ChardevSpiceChannel(Visitor *v, const char *name, ChardevSpiceChannel **obj, Error **errp)
4681{
4682 Error *err = NULL;
4683
4684 visit_start_struct(v, name, (void **)obj, sizeof(ChardevSpiceChannel), &err);
4685 if (err) {
4686 goto out;
4687 }
4688 if (!*obj) {
4689 goto out_obj;
4690 }
4691 visit_type_ChardevSpiceChannel_members(v, *obj, &err);
4692 if (err) {
4693 goto out_obj;
4694 }
4695 visit_check_struct(v, &err);
4696out_obj:
4697 visit_end_struct(v, (void **)obj);
4698 if (err && visit_is_input(v)) {
4699 qapi_free_ChardevSpiceChannel(*obj);
4700 *obj = NULL;
4701 }
4702out:
4703 error_propagate(errp, err);
4704}
4705
4706void visit_type_ChardevSpicePort_members(Visitor *v, ChardevSpicePort *obj, Error **errp)
4707{
4708 Error *err = NULL;
4709
4710 visit_type_ChardevCommon_members(v, (ChardevCommon *)obj, &err);
4711 if (err) {
4712 goto out;
4713 }
4714 visit_type_str(v, "fqdn", &obj->fqdn, &err);
4715 if (err) {
4716 goto out;
4717 }
4718
4719out:
4720 error_propagate(errp, err);
4721}
4722
4723void visit_type_ChardevSpicePort(Visitor *v, const char *name, ChardevSpicePort **obj, Error **errp)
4724{
4725 Error *err = NULL;
4726
4727 visit_start_struct(v, name, (void **)obj, sizeof(ChardevSpicePort), &err);
4728 if (err) {
4729 goto out;
4730 }
4731 if (!*obj) {
4732 goto out_obj;
4733 }
4734 visit_type_ChardevSpicePort_members(v, *obj, &err);
4735 if (err) {
4736 goto out_obj;
4737 }
4738 visit_check_struct(v, &err);
4739out_obj:
4740 visit_end_struct(v, (void **)obj);
4741 if (err && visit_is_input(v)) {
4742 qapi_free_ChardevSpicePort(*obj);
4743 *obj = NULL;
4744 }
4745out:
4746 error_propagate(errp, err);
4747}
4748
4749void visit_type_ChardevStdio_members(Visitor *v, ChardevStdio *obj, Error **errp)
4750{
4751 Error *err = NULL;
4752
4753 visit_type_ChardevCommon_members(v, (ChardevCommon *)obj, &err);
4754 if (err) {
4755 goto out;
4756 }
4757 if (visit_optional(v, "signal", &obj->has_signal)) {
4758 visit_type_bool(v, "signal", &obj->signal, &err);
4759 if (err) {
4760 goto out;
4761 }
4762 }
4763
4764out:
4765 error_propagate(errp, err);
4766}
4767
4768void visit_type_ChardevStdio(Visitor *v, const char *name, ChardevStdio **obj, Error **errp)
4769{
4770 Error *err = NULL;
4771
4772 visit_start_struct(v, name, (void **)obj, sizeof(ChardevStdio), &err);
4773 if (err) {
4774 goto out;
4775 }
4776 if (!*obj) {
4777 goto out_obj;
4778 }
4779 visit_type_ChardevStdio_members(v, *obj, &err);
4780 if (err) {
4781 goto out_obj;
4782 }
4783 visit_check_struct(v, &err);
4784out_obj:
4785 visit_end_struct(v, (void **)obj);
4786 if (err && visit_is_input(v)) {
4787 qapi_free_ChardevStdio(*obj);
4788 *obj = NULL;
4789 }
4790out:
4791 error_propagate(errp, err);
4792}
4793
4794void visit_type_ChardevUdp_members(Visitor *v, ChardevUdp *obj, Error **errp)
4795{
4796 Error *err = NULL;
4797
4798 visit_type_ChardevCommon_members(v, (ChardevCommon *)obj, &err);
4799 if (err) {
4800 goto out;
4801 }
4802 visit_type_SocketAddressLegacy(v, "remote", &obj->remote, &err);
4803 if (err) {
4804 goto out;
4805 }
4806 if (visit_optional(v, "local", &obj->has_local)) {
4807 visit_type_SocketAddressLegacy(v, "local", &obj->local, &err);
4808 if (err) {
4809 goto out;
4810 }
4811 }
4812
4813out:
4814 error_propagate(errp, err);
4815}
4816
4817void visit_type_ChardevUdp(Visitor *v, const char *name, ChardevUdp **obj, Error **errp)
4818{
4819 Error *err = NULL;
4820
4821 visit_start_struct(v, name, (void **)obj, sizeof(ChardevUdp), &err);
4822 if (err) {
4823 goto out;
4824 }
4825 if (!*obj) {
4826 goto out_obj;
4827 }
4828 visit_type_ChardevUdp_members(v, *obj, &err);
4829 if (err) {
4830 goto out_obj;
4831 }
4832 visit_check_struct(v, &err);
4833out_obj:
4834 visit_end_struct(v, (void **)obj);
4835 if (err && visit_is_input(v)) {
4836 qapi_free_ChardevUdp(*obj);
4837 *obj = NULL;
4838 }
4839out:
4840 error_propagate(errp, err);
4841}
4842
4843void visit_type_ChardevVC_members(Visitor *v, ChardevVC *obj, Error **errp)
4844{
4845 Error *err = NULL;
4846
4847 visit_type_ChardevCommon_members(v, (ChardevCommon *)obj, &err);
4848 if (err) {
4849 goto out;
4850 }
4851 if (visit_optional(v, "width", &obj->has_width)) {
4852 visit_type_int(v, "width", &obj->width, &err);
4853 if (err) {
4854 goto out;
4855 }
4856 }
4857 if (visit_optional(v, "height", &obj->has_height)) {
4858 visit_type_int(v, "height", &obj->height, &err);
4859 if (err) {
4860 goto out;
4861 }
4862 }
4863 if (visit_optional(v, "cols", &obj->has_cols)) {
4864 visit_type_int(v, "cols", &obj->cols, &err);
4865 if (err) {
4866 goto out;
4867 }
4868 }
4869 if (visit_optional(v, "rows", &obj->has_rows)) {
4870 visit_type_int(v, "rows", &obj->rows, &err);
4871 if (err) {
4872 goto out;
4873 }
4874 }
4875
4876out:
4877 error_propagate(errp, err);
4878}
4879
4880void visit_type_ChardevVC(Visitor *v, const char *name, ChardevVC **obj, Error **errp)
4881{
4882 Error *err = NULL;
4883
4884 visit_start_struct(v, name, (void **)obj, sizeof(ChardevVC), &err);
4885 if (err) {
4886 goto out;
4887 }
4888 if (!*obj) {
4889 goto out_obj;
4890 }
4891 visit_type_ChardevVC_members(v, *obj, &err);
4892 if (err) {
4893 goto out_obj;
4894 }
4895 visit_check_struct(v, &err);
4896out_obj:
4897 visit_end_struct(v, (void **)obj);
4898 if (err && visit_is_input(v)) {
4899 qapi_free_ChardevVC(*obj);
4900 *obj = NULL;
4901 }
4902out:
4903 error_propagate(errp, err);
4904}
4905
4906void visit_type_CommandInfo_members(Visitor *v, CommandInfo *obj, Error **errp)
4907{
4908 Error *err = NULL;
4909
4910 visit_type_str(v, "name", &obj->name, &err);
4911 if (err) {
4912 goto out;
4913 }
4914
4915out:
4916 error_propagate(errp, err);
4917}
4918
4919void visit_type_CommandInfo(Visitor *v, const char *name, CommandInfo **obj, Error **errp)
4920{
4921 Error *err = NULL;
4922
4923 visit_start_struct(v, name, (void **)obj, sizeof(CommandInfo), &err);
4924 if (err) {
4925 goto out;
4926 }
4927 if (!*obj) {
4928 goto out_obj;
4929 }
4930 visit_type_CommandInfo_members(v, *obj, &err);
4931 if (err) {
4932 goto out_obj;
4933 }
4934 visit_check_struct(v, &err);
4935out_obj:
4936 visit_end_struct(v, (void **)obj);
4937 if (err && visit_is_input(v)) {
4938 qapi_free_CommandInfo(*obj);
4939 *obj = NULL;
4940 }
4941out:
4942 error_propagate(errp, err);
4943}
4944
4945void visit_type_CommandInfoList(Visitor *v, const char *name, CommandInfoList **obj, Error **errp)
4946{
4947 Error *err = NULL;
4948 CommandInfoList *tail;
4949 size_t size = sizeof(**obj);
4950
4951 visit_start_list(v, name, (GenericList **)obj, size, &err);
4952 if (err) {
4953 goto out;
4954 }
4955
4956 for (tail = *obj; tail;
4957 tail = (CommandInfoList *)visit_next_list(v, (GenericList *)tail, size)) {
4958 visit_type_CommandInfo(v, NULL, &tail->value, &err);
4959 if (err) {
4960 break;
4961 }
4962 }
4963
4964 if (!err) {
4965 visit_check_list(v, &err);
4966 }
4967 visit_end_list(v, (void **)obj);
4968 if (err && visit_is_input(v)) {
4969 qapi_free_CommandInfoList(*obj);
4970 *obj = NULL;
4971 }
4972out:
4973 error_propagate(errp, err);
4974}
4975
4976void visit_type_CommandLineOptionInfo_members(Visitor *v, CommandLineOptionInfo *obj, Error **errp)
4977{
4978 Error *err = NULL;
4979
4980 visit_type_str(v, "option", &obj->option, &err);
4981 if (err) {
4982 goto out;
4983 }
4984 visit_type_CommandLineParameterInfoList(v, "parameters", &obj->parameters, &err);
4985 if (err) {
4986 goto out;
4987 }
4988
4989out:
4990 error_propagate(errp, err);
4991}
4992
4993void visit_type_CommandLineOptionInfo(Visitor *v, const char *name, CommandLineOptionInfo **obj, Error **errp)
4994{
4995 Error *err = NULL;
4996
4997 visit_start_struct(v, name, (void **)obj, sizeof(CommandLineOptionInfo), &err);
4998 if (err) {
4999 goto out;
5000 }
5001 if (!*obj) {
5002 goto out_obj;
5003 }
5004 visit_type_CommandLineOptionInfo_members(v, *obj, &err);
5005 if (err) {
5006 goto out_obj;
5007 }
5008 visit_check_struct(v, &err);
5009out_obj:
5010 visit_end_struct(v, (void **)obj);
5011 if (err && visit_is_input(v)) {
5012 qapi_free_CommandLineOptionInfo(*obj);
5013 *obj = NULL;
5014 }
5015out:
5016 error_propagate(errp, err);
5017}
5018
5019void visit_type_CommandLineOptionInfoList(Visitor *v, const char *name, CommandLineOptionInfoList **obj, Error **errp)
5020{
5021 Error *err = NULL;
5022 CommandLineOptionInfoList *tail;
5023 size_t size = sizeof(**obj);
5024
5025 visit_start_list(v, name, (GenericList **)obj, size, &err);
5026 if (err) {
5027 goto out;
5028 }
5029
5030 for (tail = *obj; tail;
5031 tail = (CommandLineOptionInfoList *)visit_next_list(v, (GenericList *)tail, size)) {
5032 visit_type_CommandLineOptionInfo(v, NULL, &tail->value, &err);
5033 if (err) {
5034 break;
5035 }
5036 }
5037
5038 if (!err) {
5039 visit_check_list(v, &err);
5040 }
5041 visit_end_list(v, (void **)obj);
5042 if (err && visit_is_input(v)) {
5043 qapi_free_CommandLineOptionInfoList(*obj);
5044 *obj = NULL;
5045 }
5046out:
5047 error_propagate(errp, err);
5048}
5049
5050void visit_type_CommandLineParameterInfo_members(Visitor *v, CommandLineParameterInfo *obj, Error **errp)
5051{
5052 Error *err = NULL;
5053
5054 visit_type_str(v, "name", &obj->name, &err);
5055 if (err) {
5056 goto out;
5057 }
5058 visit_type_CommandLineParameterType(v, "type", &obj->type, &err);
5059 if (err) {
5060 goto out;
5061 }
5062 if (visit_optional(v, "help", &obj->has_help)) {
5063 visit_type_str(v, "help", &obj->help, &err);
5064 if (err) {
5065 goto out;
5066 }
5067 }
5068 if (visit_optional(v, "default", &obj->has_q_default)) {
5069 visit_type_str(v, "default", &obj->q_default, &err);
5070 if (err) {
5071 goto out;
5072 }
5073 }
5074
5075out:
5076 error_propagate(errp, err);
5077}
5078
5079void visit_type_CommandLineParameterInfo(Visitor *v, const char *name, CommandLineParameterInfo **obj, Error **errp)
5080{
5081 Error *err = NULL;
5082
5083 visit_start_struct(v, name, (void **)obj, sizeof(CommandLineParameterInfo), &err);
5084 if (err) {
5085 goto out;
5086 }
5087 if (!*obj) {
5088 goto out_obj;
5089 }
5090 visit_type_CommandLineParameterInfo_members(v, *obj, &err);
5091 if (err) {
5092 goto out_obj;
5093 }
5094 visit_check_struct(v, &err);
5095out_obj:
5096 visit_end_struct(v, (void **)obj);
5097 if (err && visit_is_input(v)) {
5098 qapi_free_CommandLineParameterInfo(*obj);
5099 *obj = NULL;
5100 }
5101out:
5102 error_propagate(errp, err);
5103}
5104
5105void visit_type_CommandLineParameterInfoList(Visitor *v, const char *name, CommandLineParameterInfoList **obj, Error **errp)
5106{
5107 Error *err = NULL;
5108 CommandLineParameterInfoList *tail;
5109 size_t size = sizeof(**obj);
5110
5111 visit_start_list(v, name, (GenericList **)obj, size, &err);
5112 if (err) {
5113 goto out;
5114 }
5115
5116 for (tail = *obj; tail;
5117 tail = (CommandLineParameterInfoList *)visit_next_list(v, (GenericList *)tail, size)) {
5118 visit_type_CommandLineParameterInfo(v, NULL, &tail->value, &err);
5119 if (err) {
5120 break;
5121 }
5122 }
5123
5124 if (!err) {
5125 visit_check_list(v, &err);
5126 }
5127 visit_end_list(v, (void **)obj);
5128 if (err && visit_is_input(v)) {
5129 qapi_free_CommandLineParameterInfoList(*obj);
5130 *obj = NULL;
5131 }
5132out:
5133 error_propagate(errp, err);
5134}
5135
5136void visit_type_CommandLineParameterType(Visitor *v, const char *name, CommandLineParameterType *obj, Error **errp)
5137{
5138 int value = *obj;
5139 visit_type_enum(v, name, &value, CommandLineParameterType_lookup, errp);
5140 *obj = value;
5141}
5142
5143void visit_type_CpuDefinitionInfo_members(Visitor *v, CpuDefinitionInfo *obj, Error **errp)
5144{
5145 Error *err = NULL;
5146
5147 visit_type_str(v, "name", &obj->name, &err);
5148 if (err) {
5149 goto out;
5150 }
5151 if (visit_optional(v, "migration-safe", &obj->has_migration_safe)) {
5152 visit_type_bool(v, "migration-safe", &obj->migration_safe, &err);
5153 if (err) {
5154 goto out;
5155 }
5156 }
5157 visit_type_bool(v, "static", &obj->q_static, &err);
5158 if (err) {
5159 goto out;
5160 }
5161 if (visit_optional(v, "unavailable-features", &obj->has_unavailable_features)) {
5162 visit_type_strList(v, "unavailable-features", &obj->unavailable_features, &err);
5163 if (err) {
5164 goto out;
5165 }
5166 }
5167 visit_type_str(v, "typename", &obj->q_typename, &err);
5168 if (err) {
5169 goto out;
5170 }
5171
5172out:
5173 error_propagate(errp, err);
5174}
5175
5176void visit_type_CpuDefinitionInfo(Visitor *v, const char *name, CpuDefinitionInfo **obj, Error **errp)
5177{
5178 Error *err = NULL;
5179
5180 visit_start_struct(v, name, (void **)obj, sizeof(CpuDefinitionInfo), &err);
5181 if (err) {
5182 goto out;
5183 }
5184 if (!*obj) {
5185 goto out_obj;
5186 }
5187 visit_type_CpuDefinitionInfo_members(v, *obj, &err);
5188 if (err) {
5189 goto out_obj;
5190 }
5191 visit_check_struct(v, &err);
5192out_obj:
5193 visit_end_struct(v, (void **)obj);
5194 if (err && visit_is_input(v)) {
5195 qapi_free_CpuDefinitionInfo(*obj);
5196 *obj = NULL;
5197 }
5198out:
5199 error_propagate(errp, err);
5200}
5201
5202void visit_type_CpuDefinitionInfoList(Visitor *v, const char *name, CpuDefinitionInfoList **obj, Error **errp)
5203{
5204 Error *err = NULL;
5205 CpuDefinitionInfoList *tail;
5206 size_t size = sizeof(**obj);
5207
5208 visit_start_list(v, name, (GenericList **)obj, size, &err);
5209 if (err) {
5210 goto out;
5211 }
5212
5213 for (tail = *obj; tail;
5214 tail = (CpuDefinitionInfoList *)visit_next_list(v, (GenericList *)tail, size)) {
5215 visit_type_CpuDefinitionInfo(v, NULL, &tail->value, &err);
5216 if (err) {
5217 break;
5218 }
5219 }
5220
5221 if (!err) {
5222 visit_check_list(v, &err);
5223 }
5224 visit_end_list(v, (void **)obj);
5225 if (err && visit_is_input(v)) {
5226 qapi_free_CpuDefinitionInfoList(*obj);
5227 *obj = NULL;
5228 }
5229out:
5230 error_propagate(errp, err);
5231}
5232
5233void visit_type_CpuInfo_members(Visitor *v, CpuInfo *obj, Error **errp)
5234{
5235 Error *err = NULL;
5236
5237 visit_type_q_obj_CpuInfo_base_members(v, (q_obj_CpuInfo_base *)obj, &err);
5238 if (err) {
5239 goto out;
5240 }
5241 switch (obj->arch) {
5242 case CPU_INFO_ARCH_X86:
5243 visit_type_CpuInfoX86_members(v, &obj->u.x86, &err);
5244 break;
5245 case CPU_INFO_ARCH_SPARC:
5246 visit_type_CpuInfoSPARC_members(v, &obj->u.q_sparc, &err);
5247 break;
5248 case CPU_INFO_ARCH_PPC:
5249 visit_type_CpuInfoPPC_members(v, &obj->u.ppc, &err);
5250 break;
5251 case CPU_INFO_ARCH_MIPS:
5252 visit_type_CpuInfoMIPS_members(v, &obj->u.q_mips, &err);
5253 break;
5254 case CPU_INFO_ARCH_TRICORE:
5255 visit_type_CpuInfoTricore_members(v, &obj->u.tricore, &err);
5256 break;
5257 case CPU_INFO_ARCH_OTHER:
5258 visit_type_CpuInfoOther_members(v, &obj->u.other, &err);
5259 break;
5260 default:
5261 abort();
5262 }
5263
5264out:
5265 error_propagate(errp, err);
5266}
5267
5268void visit_type_CpuInfo(Visitor *v, const char *name, CpuInfo **obj, Error **errp)
5269{
5270 Error *err = NULL;
5271
5272 visit_start_struct(v, name, (void **)obj, sizeof(CpuInfo), &err);
5273 if (err) {
5274 goto out;
5275 }
5276 if (!*obj) {
5277 goto out_obj;
5278 }
5279 visit_type_CpuInfo_members(v, *obj, &err);
5280 if (err) {
5281 goto out_obj;
5282 }
5283 visit_check_struct(v, &err);
5284out_obj:
5285 visit_end_struct(v, (void **)obj);
5286 if (err && visit_is_input(v)) {
5287 qapi_free_CpuInfo(*obj);
5288 *obj = NULL;
5289 }
5290out:
5291 error_propagate(errp, err);
5292}
5293
5294void visit_type_CpuInfoArch(Visitor *v, const char *name, CpuInfoArch *obj, Error **errp)
5295{
5296 int value = *obj;
5297 visit_type_enum(v, name, &value, CpuInfoArch_lookup, errp);
5298 *obj = value;
5299}
5300
5301void visit_type_CpuInfoList(Visitor *v, const char *name, CpuInfoList **obj, Error **errp)
5302{
5303 Error *err = NULL;
5304 CpuInfoList *tail;
5305 size_t size = sizeof(**obj);
5306
5307 visit_start_list(v, name, (GenericList **)obj, size, &err);
5308 if (err) {
5309 goto out;
5310 }
5311
5312 for (tail = *obj; tail;
5313 tail = (CpuInfoList *)visit_next_list(v, (GenericList *)tail, size)) {
5314 visit_type_CpuInfo(v, NULL, &tail->value, &err);
5315 if (err) {
5316 break;
5317 }
5318 }
5319
5320 if (!err) {
5321 visit_check_list(v, &err);
5322 }
5323 visit_end_list(v, (void **)obj);
5324 if (err && visit_is_input(v)) {
5325 qapi_free_CpuInfoList(*obj);
5326 *obj = NULL;
5327 }
5328out:
5329 error_propagate(errp, err);
5330}
5331
5332void visit_type_CpuInfoMIPS_members(Visitor *v, CpuInfoMIPS *obj, Error **errp)
5333{
5334 Error *err = NULL;
5335
5336 visit_type_int(v, "PC", &obj->PC, &err);
5337 if (err) {
5338 goto out;
5339 }
5340
5341out:
5342 error_propagate(errp, err);
5343}
5344
5345void visit_type_CpuInfoMIPS(Visitor *v, const char *name, CpuInfoMIPS **obj, Error **errp)
5346{
5347 Error *err = NULL;
5348
5349 visit_start_struct(v, name, (void **)obj, sizeof(CpuInfoMIPS), &err);
5350 if (err) {
5351 goto out;
5352 }
5353 if (!*obj) {
5354 goto out_obj;
5355 }
5356 visit_type_CpuInfoMIPS_members(v, *obj, &err);
5357 if (err) {
5358 goto out_obj;
5359 }
5360 visit_check_struct(v, &err);
5361out_obj:
5362 visit_end_struct(v, (void **)obj);
5363 if (err && visit_is_input(v)) {
5364 qapi_free_CpuInfoMIPS(*obj);
5365 *obj = NULL;
5366 }
5367out:
5368 error_propagate(errp, err);
5369}
5370
5371void visit_type_CpuInfoOther_members(Visitor *v, CpuInfoOther *obj, Error **errp)
5372{
5373 Error *err = NULL;
5374
5375 error_propagate(errp, err);
5376}
5377
5378void visit_type_CpuInfoOther(Visitor *v, const char *name, CpuInfoOther **obj, Error **errp)
5379{
5380 Error *err = NULL;
5381
5382 visit_start_struct(v, name, (void **)obj, sizeof(CpuInfoOther), &err);
5383 if (err) {
5384 goto out;
5385 }
5386 if (!*obj) {
5387 goto out_obj;
5388 }
5389 visit_type_CpuInfoOther_members(v, *obj, &err);
5390 if (err) {
5391 goto out_obj;
5392 }
5393 visit_check_struct(v, &err);
5394out_obj:
5395 visit_end_struct(v, (void **)obj);
5396 if (err && visit_is_input(v)) {
5397 qapi_free_CpuInfoOther(*obj);
5398 *obj = NULL;
5399 }
5400out:
5401 error_propagate(errp, err);
5402}
5403
5404void visit_type_CpuInfoPPC_members(Visitor *v, CpuInfoPPC *obj, Error **errp)
5405{
5406 Error *err = NULL;
5407
5408 visit_type_int(v, "nip", &obj->nip, &err);
5409 if (err) {
5410 goto out;
5411 }
5412
5413out:
5414 error_propagate(errp, err);
5415}
5416
5417void visit_type_CpuInfoPPC(Visitor *v, const char *name, CpuInfoPPC **obj, Error **errp)
5418{
5419 Error *err = NULL;
5420
5421 visit_start_struct(v, name, (void **)obj, sizeof(CpuInfoPPC), &err);
5422 if (err) {
5423 goto out;
5424 }
5425 if (!*obj) {
5426 goto out_obj;
5427 }
5428 visit_type_CpuInfoPPC_members(v, *obj, &err);
5429 if (err) {
5430 goto out_obj;
5431 }
5432 visit_check_struct(v, &err);
5433out_obj:
5434 visit_end_struct(v, (void **)obj);
5435 if (err && visit_is_input(v)) {
5436 qapi_free_CpuInfoPPC(*obj);
5437 *obj = NULL;
5438 }
5439out:
5440 error_propagate(errp, err);
5441}
5442
5443void visit_type_CpuInfoSPARC_members(Visitor *v, CpuInfoSPARC *obj, Error **errp)
5444{
5445 Error *err = NULL;
5446
5447 visit_type_int(v, "pc", &obj->pc, &err);
5448 if (err) {
5449 goto out;
5450 }
5451 visit_type_int(v, "npc", &obj->npc, &err);
5452 if (err) {
5453 goto out;
5454 }
5455
5456out:
5457 error_propagate(errp, err);
5458}
5459
5460void visit_type_CpuInfoSPARC(Visitor *v, const char *name, CpuInfoSPARC **obj, Error **errp)
5461{
5462 Error *err = NULL;
5463
5464 visit_start_struct(v, name, (void **)obj, sizeof(CpuInfoSPARC), &err);
5465 if (err) {
5466 goto out;
5467 }
5468 if (!*obj) {
5469 goto out_obj;
5470 }
5471 visit_type_CpuInfoSPARC_members(v, *obj, &err);
5472 if (err) {
5473 goto out_obj;
5474 }
5475 visit_check_struct(v, &err);
5476out_obj:
5477 visit_end_struct(v, (void **)obj);
5478 if (err && visit_is_input(v)) {
5479 qapi_free_CpuInfoSPARC(*obj);
5480 *obj = NULL;
5481 }
5482out:
5483 error_propagate(errp, err);
5484}
5485
5486void visit_type_CpuInfoTricore_members(Visitor *v, CpuInfoTricore *obj, Error **errp)
5487{
5488 Error *err = NULL;
5489
5490 visit_type_int(v, "PC", &obj->PC, &err);
5491 if (err) {
5492 goto out;
5493 }
5494
5495out:
5496 error_propagate(errp, err);
5497}
5498
5499void visit_type_CpuInfoTricore(Visitor *v, const char *name, CpuInfoTricore **obj, Error **errp)
5500{
5501 Error *err = NULL;
5502
5503 visit_start_struct(v, name, (void **)obj, sizeof(CpuInfoTricore), &err);
5504 if (err) {
5505 goto out;
5506 }
5507 if (!*obj) {
5508 goto out_obj;
5509 }
5510 visit_type_CpuInfoTricore_members(v, *obj, &err);
5511 if (err) {
5512 goto out_obj;
5513 }
5514 visit_check_struct(v, &err);
5515out_obj:
5516 visit_end_struct(v, (void **)obj);
5517 if (err && visit_is_input(v)) {
5518 qapi_free_CpuInfoTricore(*obj);
5519 *obj = NULL;
5520 }
5521out:
5522 error_propagate(errp, err);
5523}
5524
5525void visit_type_CpuInfoX86_members(Visitor *v, CpuInfoX86 *obj, Error **errp)
5526{
5527 Error *err = NULL;
5528
5529 visit_type_int(v, "pc", &obj->pc, &err);
5530 if (err) {
5531 goto out;
5532 }
5533
5534out:
5535 error_propagate(errp, err);
5536}
5537
5538void visit_type_CpuInfoX86(Visitor *v, const char *name, CpuInfoX86 **obj, Error **errp)
5539{
5540 Error *err = NULL;
5541
5542 visit_start_struct(v, name, (void **)obj, sizeof(CpuInfoX86), &err);
5543 if (err) {
5544 goto out;
5545 }
5546 if (!*obj) {
5547 goto out_obj;
5548 }
5549 visit_type_CpuInfoX86_members(v, *obj, &err);
5550 if (err) {
5551 goto out_obj;
5552 }
5553 visit_check_struct(v, &err);
5554out_obj:
5555 visit_end_struct(v, (void **)obj);
5556 if (err && visit_is_input(v)) {
5557 qapi_free_CpuInfoX86(*obj);
5558 *obj = NULL;
5559 }
5560out:
5561 error_propagate(errp, err);
5562}
5563
5564void visit_type_CpuInstanceProperties_members(Visitor *v, CpuInstanceProperties *obj, Error **errp)
5565{
5566 Error *err = NULL;
5567
5568 if (visit_optional(v, "node-id", &obj->has_node_id)) {
5569 visit_type_int(v, "node-id", &obj->node_id, &err);
5570 if (err) {
5571 goto out;
5572 }
5573 }
5574 if (visit_optional(v, "socket-id", &obj->has_socket_id)) {
5575 visit_type_int(v, "socket-id", &obj->socket_id, &err);
5576 if (err) {
5577 goto out;
5578 }
5579 }
5580 if (visit_optional(v, "core-id", &obj->has_core_id)) {
5581 visit_type_int(v, "core-id", &obj->core_id, &err);
5582 if (err) {
5583 goto out;
5584 }
5585 }
5586 if (visit_optional(v, "thread-id", &obj->has_thread_id)) {
5587 visit_type_int(v, "thread-id", &obj->thread_id, &err);
5588 if (err) {
5589 goto out;
5590 }
5591 }
5592
5593out:
5594 error_propagate(errp, err);
5595}
5596
5597void visit_type_CpuInstanceProperties(Visitor *v, const char *name, CpuInstanceProperties **obj, Error **errp)
5598{
5599 Error *err = NULL;
5600
5601 visit_start_struct(v, name, (void **)obj, sizeof(CpuInstanceProperties), &err);
5602 if (err) {
5603 goto out;
5604 }
5605 if (!*obj) {
5606 goto out_obj;
5607 }
5608 visit_type_CpuInstanceProperties_members(v, *obj, &err);
5609 if (err) {
5610 goto out_obj;
5611 }
5612 visit_check_struct(v, &err);
5613out_obj:
5614 visit_end_struct(v, (void **)obj);
5615 if (err && visit_is_input(v)) {
5616 qapi_free_CpuInstanceProperties(*obj);
5617 *obj = NULL;
5618 }
5619out:
5620 error_propagate(errp, err);
5621}
5622
5623void visit_type_CpuModelBaselineInfo_members(Visitor *v, CpuModelBaselineInfo *obj, Error **errp)
5624{
5625 Error *err = NULL;
5626
5627 visit_type_CpuModelInfo(v, "model", &obj->model, &err);
5628 if (err) {
5629 goto out;
5630 }
5631
5632out:
5633 error_propagate(errp, err);
5634}
5635
5636void visit_type_CpuModelBaselineInfo(Visitor *v, const char *name, CpuModelBaselineInfo **obj, Error **errp)
5637{
5638 Error *err = NULL;
5639
5640 visit_start_struct(v, name, (void **)obj, sizeof(CpuModelBaselineInfo), &err);
5641 if (err) {
5642 goto out;
5643 }
5644 if (!*obj) {
5645 goto out_obj;
5646 }
5647 visit_type_CpuModelBaselineInfo_members(v, *obj, &err);
5648 if (err) {
5649 goto out_obj;
5650 }
5651 visit_check_struct(v, &err);
5652out_obj:
5653 visit_end_struct(v, (void **)obj);
5654 if (err && visit_is_input(v)) {
5655 qapi_free_CpuModelBaselineInfo(*obj);
5656 *obj = NULL;
5657 }
5658out:
5659 error_propagate(errp, err);
5660}
5661
5662void visit_type_CpuModelCompareInfo_members(Visitor *v, CpuModelCompareInfo *obj, Error **errp)
5663{
5664 Error *err = NULL;
5665
5666 visit_type_CpuModelCompareResult(v, "result", &obj->result, &err);
5667 if (err) {
5668 goto out;
5669 }
5670 visit_type_strList(v, "responsible-properties", &obj->responsible_properties, &err);
5671 if (err) {
5672 goto out;
5673 }
5674
5675out:
5676 error_propagate(errp, err);
5677}
5678
5679void visit_type_CpuModelCompareInfo(Visitor *v, const char *name, CpuModelCompareInfo **obj, Error **errp)
5680{
5681 Error *err = NULL;
5682
5683 visit_start_struct(v, name, (void **)obj, sizeof(CpuModelCompareInfo), &err);
5684 if (err) {
5685 goto out;
5686 }
5687 if (!*obj) {
5688 goto out_obj;
5689 }
5690 visit_type_CpuModelCompareInfo_members(v, *obj, &err);
5691 if (err) {
5692 goto out_obj;
5693 }
5694 visit_check_struct(v, &err);
5695out_obj:
5696 visit_end_struct(v, (void **)obj);
5697 if (err && visit_is_input(v)) {
5698 qapi_free_CpuModelCompareInfo(*obj);
5699 *obj = NULL;
5700 }
5701out:
5702 error_propagate(errp, err);
5703}
5704
5705void visit_type_CpuModelCompareResult(Visitor *v, const char *name, CpuModelCompareResult *obj, Error **errp)
5706{
5707 int value = *obj;
5708 visit_type_enum(v, name, &value, CpuModelCompareResult_lookup, errp);
5709 *obj = value;
5710}
5711
5712void visit_type_CpuModelExpansionInfo_members(Visitor *v, CpuModelExpansionInfo *obj, Error **errp)
5713{
5714 Error *err = NULL;
5715
5716 visit_type_CpuModelInfo(v, "model", &obj->model, &err);
5717 if (err) {
5718 goto out;
5719 }
5720
5721out:
5722 error_propagate(errp, err);
5723}
5724
5725void visit_type_CpuModelExpansionInfo(Visitor *v, const char *name, CpuModelExpansionInfo **obj, Error **errp)
5726{
5727 Error *err = NULL;
5728
5729 visit_start_struct(v, name, (void **)obj, sizeof(CpuModelExpansionInfo), &err);
5730 if (err) {
5731 goto out;
5732 }
5733 if (!*obj) {
5734 goto out_obj;
5735 }
5736 visit_type_CpuModelExpansionInfo_members(v, *obj, &err);
5737 if (err) {
5738 goto out_obj;
5739 }
5740 visit_check_struct(v, &err);
5741out_obj:
5742 visit_end_struct(v, (void **)obj);
5743 if (err && visit_is_input(v)) {
5744 qapi_free_CpuModelExpansionInfo(*obj);
5745 *obj = NULL;
5746 }
5747out:
5748 error_propagate(errp, err);
5749}
5750
5751void visit_type_CpuModelExpansionType(Visitor *v, const char *name, CpuModelExpansionType *obj, Error **errp)
5752{
5753 int value = *obj;
5754 visit_type_enum(v, name, &value, CpuModelExpansionType_lookup, errp);
5755 *obj = value;
5756}
5757
5758void visit_type_CpuModelInfo_members(Visitor *v, CpuModelInfo *obj, Error **errp)
5759{
5760 Error *err = NULL;
5761
5762 visit_type_str(v, "name", &obj->name, &err);
5763 if (err) {
5764 goto out;
5765 }
5766 if (visit_optional(v, "props", &obj->has_props)) {
5767 visit_type_any(v, "props", &obj->props, &err);
5768 if (err) {
5769 goto out;
5770 }
5771 }
5772
5773out:
5774 error_propagate(errp, err);
5775}
5776
5777void visit_type_CpuModelInfo(Visitor *v, const char *name, CpuModelInfo **obj, Error **errp)
5778{
5779 Error *err = NULL;
5780
5781 visit_start_struct(v, name, (void **)obj, sizeof(CpuModelInfo), &err);
5782 if (err) {
5783 goto out;
5784 }
5785 if (!*obj) {
5786 goto out_obj;
5787 }
5788 visit_type_CpuModelInfo_members(v, *obj, &err);
5789 if (err) {
5790 goto out_obj;
5791 }
5792 visit_check_struct(v, &err);
5793out_obj:
5794 visit_end_struct(v, (void **)obj);
5795 if (err && visit_is_input(v)) {
5796 qapi_free_CpuModelInfo(*obj);
5797 *obj = NULL;
5798 }
5799out:
5800 error_propagate(errp, err);
5801}
5802
5803void visit_type_DataFormat(Visitor *v, const char *name, DataFormat *obj, Error **errp)
5804{
5805 int value = *obj;
5806 visit_type_enum(v, name, &value, DataFormat_lookup, errp);
5807 *obj = value;
5808}
5809
5810void visit_type_DevicePropertyInfo_members(Visitor *v, DevicePropertyInfo *obj, Error **errp)
5811{
5812 Error *err = NULL;
5813
5814 visit_type_str(v, "name", &obj->name, &err);
5815 if (err) {
5816 goto out;
5817 }
5818 visit_type_str(v, "type", &obj->type, &err);
5819 if (err) {
5820 goto out;
5821 }
5822 if (visit_optional(v, "description", &obj->has_description)) {
5823 visit_type_str(v, "description", &obj->description, &err);
5824 if (err) {
5825 goto out;
5826 }
5827 }
5828
5829out:
5830 error_propagate(errp, err);
5831}
5832
5833void visit_type_DevicePropertyInfo(Visitor *v, const char *name, DevicePropertyInfo **obj, Error **errp)
5834{
5835 Error *err = NULL;
5836
5837 visit_start_struct(v, name, (void **)obj, sizeof(DevicePropertyInfo), &err);
5838 if (err) {
5839 goto out;
5840 }
5841 if (!*obj) {
5842 goto out_obj;
5843 }
5844 visit_type_DevicePropertyInfo_members(v, *obj, &err);
5845 if (err) {
5846 goto out_obj;
5847 }
5848 visit_check_struct(v, &err);
5849out_obj:
5850 visit_end_struct(v, (void **)obj);
5851 if (err && visit_is_input(v)) {
5852 qapi_free_DevicePropertyInfo(*obj);
5853 *obj = NULL;
5854 }
5855out:
5856 error_propagate(errp, err);
5857}
5858
5859void visit_type_DevicePropertyInfoList(Visitor *v, const char *name, DevicePropertyInfoList **obj, Error **errp)
5860{
5861 Error *err = NULL;
5862 DevicePropertyInfoList *tail;
5863 size_t size = sizeof(**obj);
5864
5865 visit_start_list(v, name, (GenericList **)obj, size, &err);
5866 if (err) {
5867 goto out;
5868 }
5869
5870 for (tail = *obj; tail;
5871 tail = (DevicePropertyInfoList *)visit_next_list(v, (GenericList *)tail, size)) {
5872 visit_type_DevicePropertyInfo(v, NULL, &tail->value, &err);
5873 if (err) {
5874 break;
5875 }
5876 }
5877
5878 if (!err) {
5879 visit_check_list(v, &err);
5880 }
5881 visit_end_list(v, (void **)obj);
5882 if (err && visit_is_input(v)) {
5883 qapi_free_DevicePropertyInfoList(*obj);
5884 *obj = NULL;
5885 }
5886out:
5887 error_propagate(errp, err);
5888}
5889
5890void visit_type_DirtyBitmapStatus(Visitor *v, const char *name, DirtyBitmapStatus *obj, Error **errp)
5891{
5892 int value = *obj;
5893 visit_type_enum(v, name, &value, DirtyBitmapStatus_lookup, errp);
5894 *obj = value;
5895}
5896
5897void visit_type_DriveBackup_members(Visitor *v, DriveBackup *obj, Error **errp)
5898{
5899 Error *err = NULL;
5900
5901 if (visit_optional(v, "job-id", &obj->has_job_id)) {
5902 visit_type_str(v, "job-id", &obj->job_id, &err);
5903 if (err) {
5904 goto out;
5905 }
5906 }
5907 visit_type_str(v, "device", &obj->device, &err);
5908 if (err) {
5909 goto out;
5910 }
5911 visit_type_str(v, "target", &obj->target, &err);
5912 if (err) {
5913 goto out;
5914 }
5915 if (visit_optional(v, "format", &obj->has_format)) {
5916 visit_type_str(v, "format", &obj->format, &err);
5917 if (err) {
5918 goto out;
5919 }
5920 }
5921 visit_type_MirrorSyncMode(v, "sync", &obj->sync, &err);
5922 if (err) {
5923 goto out;
5924 }
5925 if (visit_optional(v, "mode", &obj->has_mode)) {
5926 visit_type_NewImageMode(v, "mode", &obj->mode, &err);
5927 if (err) {
5928 goto out;
5929 }
5930 }
5931 if (visit_optional(v, "speed", &obj->has_speed)) {
5932 visit_type_int(v, "speed", &obj->speed, &err);
5933 if (err) {
5934 goto out;
5935 }
5936 }
5937 if (visit_optional(v, "bitmap", &obj->has_bitmap)) {
5938 visit_type_str(v, "bitmap", &obj->bitmap, &err);
5939 if (err) {
5940 goto out;
5941 }
5942 }
5943 if (visit_optional(v, "compress", &obj->has_compress)) {
5944 visit_type_bool(v, "compress", &obj->compress, &err);
5945 if (err) {
5946 goto out;
5947 }
5948 }
5949 if (visit_optional(v, "on-source-error", &obj->has_on_source_error)) {
5950 visit_type_BlockdevOnError(v, "on-source-error", &obj->on_source_error, &err);
5951 if (err) {
5952 goto out;
5953 }
5954 }
5955 if (visit_optional(v, "on-target-error", &obj->has_on_target_error)) {
5956 visit_type_BlockdevOnError(v, "on-target-error", &obj->on_target_error, &err);
5957 if (err) {
5958 goto out;
5959 }
5960 }
5961
5962out:
5963 error_propagate(errp, err);
5964}
5965
5966void visit_type_DriveBackup(Visitor *v, const char *name, DriveBackup **obj, Error **errp)
5967{
5968 Error *err = NULL;
5969
5970 visit_start_struct(v, name, (void **)obj, sizeof(DriveBackup), &err);
5971 if (err) {
5972 goto out;
5973 }
5974 if (!*obj) {
5975 goto out_obj;
5976 }
5977 visit_type_DriveBackup_members(v, *obj, &err);
5978 if (err) {
5979 goto out_obj;
5980 }
5981 visit_check_struct(v, &err);
5982out_obj:
5983 visit_end_struct(v, (void **)obj);
5984 if (err && visit_is_input(v)) {
5985 qapi_free_DriveBackup(*obj);
5986 *obj = NULL;
5987 }
5988out:
5989 error_propagate(errp, err);
5990}
5991
5992void visit_type_DriveMirror_members(Visitor *v, DriveMirror *obj, Error **errp)
5993{
5994 Error *err = NULL;
5995
5996 if (visit_optional(v, "job-id", &obj->has_job_id)) {
5997 visit_type_str(v, "job-id", &obj->job_id, &err);
5998 if (err) {
5999 goto out;
6000 }
6001 }
6002 visit_type_str(v, "device", &obj->device, &err);
6003 if (err) {
6004 goto out;
6005 }
6006 visit_type_str(v, "target", &obj->target, &err);
6007 if (err) {
6008 goto out;
6009 }
6010 if (visit_optional(v, "format", &obj->has_format)) {
6011 visit_type_str(v, "format", &obj->format, &err);
6012 if (err) {
6013 goto out;
6014 }
6015 }
6016 if (visit_optional(v, "node-name", &obj->has_node_name)) {
6017 visit_type_str(v, "node-name", &obj->node_name, &err);
6018 if (err) {
6019 goto out;
6020 }
6021 }
6022 if (visit_optional(v, "replaces", &obj->has_replaces)) {
6023 visit_type_str(v, "replaces", &obj->replaces, &err);
6024 if (err) {
6025 goto out;
6026 }
6027 }
6028 visit_type_MirrorSyncMode(v, "sync", &obj->sync, &err);
6029 if (err) {
6030 goto out;
6031 }
6032 if (visit_optional(v, "mode", &obj->has_mode)) {
6033 visit_type_NewImageMode(v, "mode", &obj->mode, &err);
6034 if (err) {
6035 goto out;
6036 }
6037 }
6038 if (visit_optional(v, "speed", &obj->has_speed)) {
6039 visit_type_int(v, "speed", &obj->speed, &err);
6040 if (err) {
6041 goto out;
6042 }
6043 }
6044 if (visit_optional(v, "granularity", &obj->has_granularity)) {
6045 visit_type_uint32(v, "granularity", &obj->granularity, &err);
6046 if (err) {
6047 goto out;
6048 }
6049 }
6050 if (visit_optional(v, "buf-size", &obj->has_buf_size)) {
6051 visit_type_int(v, "buf-size", &obj->buf_size, &err);
6052 if (err) {
6053 goto out;
6054 }
6055 }
6056 if (visit_optional(v, "on-source-error", &obj->has_on_source_error)) {
6057 visit_type_BlockdevOnError(v, "on-source-error", &obj->on_source_error, &err);
6058 if (err) {
6059 goto out;
6060 }
6061 }
6062 if (visit_optional(v, "on-target-error", &obj->has_on_target_error)) {
6063 visit_type_BlockdevOnError(v, "on-target-error", &obj->on_target_error, &err);
6064 if (err) {
6065 goto out;
6066 }
6067 }
6068 if (visit_optional(v, "unmap", &obj->has_unmap)) {
6069 visit_type_bool(v, "unmap", &obj->unmap, &err);
6070 if (err) {
6071 goto out;
6072 }
6073 }
6074
6075out:
6076 error_propagate(errp, err);
6077}
6078
6079void visit_type_DriveMirror(Visitor *v, const char *name, DriveMirror **obj, Error **errp)
6080{
6081 Error *err = NULL;
6082
6083 visit_start_struct(v, name, (void **)obj, sizeof(DriveMirror), &err);
6084 if (err) {
6085 goto out;
6086 }
6087 if (!*obj) {
6088 goto out_obj;
6089 }
6090 visit_type_DriveMirror_members(v, *obj, &err);
6091 if (err) {
6092 goto out_obj;
6093 }
6094 visit_check_struct(v, &err);
6095out_obj:
6096 visit_end_struct(v, (void **)obj);
6097 if (err && visit_is_input(v)) {
6098 qapi_free_DriveMirror(*obj);
6099 *obj = NULL;
6100 }
6101out:
6102 error_propagate(errp, err);
6103}
6104
6105void visit_type_DummyForceArrays_members(Visitor *v, DummyForceArrays *obj, Error **errp)
6106{
6107 Error *err = NULL;
6108
6109 visit_type_X86CPUFeatureWordInfoList(v, "unused", &obj->unused, &err);
6110 if (err) {
6111 goto out;
6112 }
6113
6114out:
6115 error_propagate(errp, err);
6116}
6117
6118void visit_type_DummyForceArrays(Visitor *v, const char *name, DummyForceArrays **obj, Error **errp)
6119{
6120 Error *err = NULL;
6121
6122 visit_start_struct(v, name, (void **)obj, sizeof(DummyForceArrays), &err);
6123 if (err) {
6124 goto out;
6125 }
6126 if (!*obj) {
6127 goto out_obj;
6128 }
6129 visit_type_DummyForceArrays_members(v, *obj, &err);
6130 if (err) {
6131 goto out_obj;
6132 }
6133 visit_check_struct(v, &err);
6134out_obj:
6135 visit_end_struct(v, (void **)obj);
6136 if (err && visit_is_input(v)) {
6137 qapi_free_DummyForceArrays(*obj);
6138 *obj = NULL;
6139 }
6140out:
6141 error_propagate(errp, err);
6142}
6143
6144void visit_type_DumpGuestMemoryCapability_members(Visitor *v, DumpGuestMemoryCapability *obj, Error **errp)
6145{
6146 Error *err = NULL;
6147
6148 visit_type_DumpGuestMemoryFormatList(v, "formats", &obj->formats, &err);
6149 if (err) {
6150 goto out;
6151 }
6152
6153out:
6154 error_propagate(errp, err);
6155}
6156
6157void visit_type_DumpGuestMemoryCapability(Visitor *v, const char *name, DumpGuestMemoryCapability **obj, Error **errp)
6158{
6159 Error *err = NULL;
6160
6161 visit_start_struct(v, name, (void **)obj, sizeof(DumpGuestMemoryCapability), &err);
6162 if (err) {
6163 goto out;
6164 }
6165 if (!*obj) {
6166 goto out_obj;
6167 }
6168 visit_type_DumpGuestMemoryCapability_members(v, *obj, &err);
6169 if (err) {
6170 goto out_obj;
6171 }
6172 visit_check_struct(v, &err);
6173out_obj:
6174 visit_end_struct(v, (void **)obj);
6175 if (err && visit_is_input(v)) {
6176 qapi_free_DumpGuestMemoryCapability(*obj);
6177 *obj = NULL;
6178 }
6179out:
6180 error_propagate(errp, err);
6181}
6182
6183void visit_type_DumpGuestMemoryFormat(Visitor *v, const char *name, DumpGuestMemoryFormat *obj, Error **errp)
6184{
6185 int value = *obj;
6186 visit_type_enum(v, name, &value, DumpGuestMemoryFormat_lookup, errp);
6187 *obj = value;
6188}
6189
6190void visit_type_DumpGuestMemoryFormatList(Visitor *v, const char *name, DumpGuestMemoryFormatList **obj, Error **errp)
6191{
6192 Error *err = NULL;
6193 DumpGuestMemoryFormatList *tail;
6194 size_t size = sizeof(**obj);
6195
6196 visit_start_list(v, name, (GenericList **)obj, size, &err);
6197 if (err) {
6198 goto out;
6199 }
6200
6201 for (tail = *obj; tail;
6202 tail = (DumpGuestMemoryFormatList *)visit_next_list(v, (GenericList *)tail, size)) {
6203 visit_type_DumpGuestMemoryFormat(v, NULL, &tail->value, &err);
6204 if (err) {
6205 break;
6206 }
6207 }
6208
6209 if (!err) {
6210 visit_check_list(v, &err);
6211 }
6212 visit_end_list(v, (void **)obj);
6213 if (err && visit_is_input(v)) {
6214 qapi_free_DumpGuestMemoryFormatList(*obj);
6215 *obj = NULL;
6216 }
6217out:
6218 error_propagate(errp, err);
6219}
6220
6221void visit_type_DumpQueryResult_members(Visitor *v, DumpQueryResult *obj, Error **errp)
6222{
6223 Error *err = NULL;
6224
6225 visit_type_DumpStatus(v, "status", &obj->status, &err);
6226 if (err) {
6227 goto out;
6228 }
6229 visit_type_int(v, "completed", &obj->completed, &err);
6230 if (err) {
6231 goto out;
6232 }
6233 visit_type_int(v, "total", &obj->total, &err);
6234 if (err) {
6235 goto out;
6236 }
6237
6238out:
6239 error_propagate(errp, err);
6240}
6241
6242void visit_type_DumpQueryResult(Visitor *v, const char *name, DumpQueryResult **obj, Error **errp)
6243{
6244 Error *err = NULL;
6245
6246 visit_start_struct(v, name, (void **)obj, sizeof(DumpQueryResult), &err);
6247 if (err) {
6248 goto out;
6249 }
6250 if (!*obj) {
6251 goto out_obj;
6252 }
6253 visit_type_DumpQueryResult_members(v, *obj, &err);
6254 if (err) {
6255 goto out_obj;
6256 }
6257 visit_check_struct(v, &err);
6258out_obj:
6259 visit_end_struct(v, (void **)obj);
6260 if (err && visit_is_input(v)) {
6261 qapi_free_DumpQueryResult(*obj);
6262 *obj = NULL;
6263 }
6264out:
6265 error_propagate(errp, err);
6266}
6267
6268void visit_type_DumpStatus(Visitor *v, const char *name, DumpStatus *obj, Error **errp)
6269{
6270 int value = *obj;
6271 visit_type_enum(v, name, &value, DumpStatus_lookup, errp);
6272 *obj = value;
6273}
6274
6275void visit_type_EventInfo_members(Visitor *v, EventInfo *obj, Error **errp)
6276{
6277 Error *err = NULL;
6278
6279 visit_type_str(v, "name", &obj->name, &err);
6280 if (err) {
6281 goto out;
6282 }
6283
6284out:
6285 error_propagate(errp, err);
6286}
6287
6288void visit_type_EventInfo(Visitor *v, const char *name, EventInfo **obj, Error **errp)
6289{
6290 Error *err = NULL;
6291
6292 visit_start_struct(v, name, (void **)obj, sizeof(EventInfo), &err);
6293 if (err) {
6294 goto out;
6295 }
6296 if (!*obj) {
6297 goto out_obj;
6298 }
6299 visit_type_EventInfo_members(v, *obj, &err);
6300 if (err) {
6301 goto out_obj;
6302 }
6303 visit_check_struct(v, &err);
6304out_obj:
6305 visit_end_struct(v, (void **)obj);
6306 if (err && visit_is_input(v)) {
6307 qapi_free_EventInfo(*obj);
6308 *obj = NULL;
6309 }
6310out:
6311 error_propagate(errp, err);
6312}
6313
6314void visit_type_EventInfoList(Visitor *v, const char *name, EventInfoList **obj, Error **errp)
6315{
6316 Error *err = NULL;
6317 EventInfoList *tail;
6318 size_t size = sizeof(**obj);
6319
6320 visit_start_list(v, name, (GenericList **)obj, size, &err);
6321 if (err) {
6322 goto out;
6323 }
6324
6325 for (tail = *obj; tail;
6326 tail = (EventInfoList *)visit_next_list(v, (GenericList *)tail, size)) {
6327 visit_type_EventInfo(v, NULL, &tail->value, &err);
6328 if (err) {
6329 break;
6330 }
6331 }
6332
6333 if (!err) {
6334 visit_check_list(v, &err);
6335 }
6336 visit_end_list(v, (void **)obj);
6337 if (err && visit_is_input(v)) {
6338 qapi_free_EventInfoList(*obj);
6339 *obj = NULL;
6340 }
6341out:
6342 error_propagate(errp, err);
6343}
6344
6345void visit_type_FailoverStatus(Visitor *v, const char *name, FailoverStatus *obj, Error **errp)
6346{
6347 int value = *obj;
6348 visit_type_enum(v, name, &value, FailoverStatus_lookup, errp);
6349 *obj = value;
6350}
6351
6352void visit_type_FdsetFdInfo_members(Visitor *v, FdsetFdInfo *obj, Error **errp)
6353{
6354 Error *err = NULL;
6355
6356 visit_type_int(v, "fd", &obj->fd, &err);
6357 if (err) {
6358 goto out;
6359 }
6360 if (visit_optional(v, "opaque", &obj->has_opaque)) {
6361 visit_type_str(v, "opaque", &obj->opaque, &err);
6362 if (err) {
6363 goto out;
6364 }
6365 }
6366
6367out:
6368 error_propagate(errp, err);
6369}
6370
6371void visit_type_FdsetFdInfo(Visitor *v, const char *name, FdsetFdInfo **obj, Error **errp)
6372{
6373 Error *err = NULL;
6374
6375 visit_start_struct(v, name, (void **)obj, sizeof(FdsetFdInfo), &err);
6376 if (err) {
6377 goto out;
6378 }
6379 if (!*obj) {
6380 goto out_obj;
6381 }
6382 visit_type_FdsetFdInfo_members(v, *obj, &err);
6383 if (err) {
6384 goto out_obj;
6385 }
6386 visit_check_struct(v, &err);
6387out_obj:
6388 visit_end_struct(v, (void **)obj);
6389 if (err && visit_is_input(v)) {
6390 qapi_free_FdsetFdInfo(*obj);
6391 *obj = NULL;
6392 }
6393out:
6394 error_propagate(errp, err);
6395}
6396
6397void visit_type_FdsetFdInfoList(Visitor *v, const char *name, FdsetFdInfoList **obj, Error **errp)
6398{
6399 Error *err = NULL;
6400 FdsetFdInfoList *tail;
6401 size_t size = sizeof(**obj);
6402
6403 visit_start_list(v, name, (GenericList **)obj, size, &err);
6404 if (err) {
6405 goto out;
6406 }
6407
6408 for (tail = *obj; tail;
6409 tail = (FdsetFdInfoList *)visit_next_list(v, (GenericList *)tail, size)) {
6410 visit_type_FdsetFdInfo(v, NULL, &tail->value, &err);
6411 if (err) {
6412 break;
6413 }
6414 }
6415
6416 if (!err) {
6417 visit_check_list(v, &err);
6418 }
6419 visit_end_list(v, (void **)obj);
6420 if (err && visit_is_input(v)) {
6421 qapi_free_FdsetFdInfoList(*obj);
6422 *obj = NULL;
6423 }
6424out:
6425 error_propagate(errp, err);
6426}
6427
6428void visit_type_FdsetInfo_members(Visitor *v, FdsetInfo *obj, Error **errp)
6429{
6430 Error *err = NULL;
6431
6432 visit_type_int(v, "fdset-id", &obj->fdset_id, &err);
6433 if (err) {
6434 goto out;
6435 }
6436 visit_type_FdsetFdInfoList(v, "fds", &obj->fds, &err);
6437 if (err) {
6438 goto out;
6439 }
6440
6441out:
6442 error_propagate(errp, err);
6443}
6444
6445void visit_type_FdsetInfo(Visitor *v, const char *name, FdsetInfo **obj, Error **errp)
6446{
6447 Error *err = NULL;
6448
6449 visit_start_struct(v, name, (void **)obj, sizeof(FdsetInfo), &err);
6450 if (err) {
6451 goto out;
6452 }
6453 if (!*obj) {
6454 goto out_obj;
6455 }
6456 visit_type_FdsetInfo_members(v, *obj, &err);
6457 if (err) {
6458 goto out_obj;
6459 }
6460 visit_check_struct(v, &err);
6461out_obj:
6462 visit_end_struct(v, (void **)obj);
6463 if (err && visit_is_input(v)) {
6464 qapi_free_FdsetInfo(*obj);
6465 *obj = NULL;
6466 }
6467out:
6468 error_propagate(errp, err);
6469}
6470
6471void visit_type_FdsetInfoList(Visitor *v, const char *name, FdsetInfoList **obj, Error **errp)
6472{
6473 Error *err = NULL;
6474 FdsetInfoList *tail;
6475 size_t size = sizeof(**obj);
6476
6477 visit_start_list(v, name, (GenericList **)obj, size, &err);
6478 if (err) {
6479 goto out;
6480 }
6481
6482 for (tail = *obj; tail;
6483 tail = (FdsetInfoList *)visit_next_list(v, (GenericList *)tail, size)) {
6484 visit_type_FdsetInfo(v, NULL, &tail->value, &err);
6485 if (err) {
6486 break;
6487 }
6488 }
6489
6490 if (!err) {
6491 visit_check_list(v, &err);
6492 }
6493 visit_end_list(v, (void **)obj);
6494 if (err && visit_is_input(v)) {
6495 qapi_free_FdsetInfoList(*obj);
6496 *obj = NULL;
6497 }
6498out:
6499 error_propagate(errp, err);
6500}
6501
6502void visit_type_FloppyDriveType(Visitor *v, const char *name, FloppyDriveType *obj, Error **errp)
6503{
6504 int value = *obj;
6505 visit_type_enum(v, name, &value, FloppyDriveType_lookup, errp);
6506 *obj = value;
6507}
6508
6509void visit_type_GICCapability_members(Visitor *v, GICCapability *obj, Error **errp)
6510{
6511 Error *err = NULL;
6512
6513 visit_type_int(v, "version", &obj->version, &err);
6514 if (err) {
6515 goto out;
6516 }
6517 visit_type_bool(v, "emulated", &obj->emulated, &err);
6518 if (err) {
6519 goto out;
6520 }
6521 visit_type_bool(v, "kernel", &obj->kernel, &err);
6522 if (err) {
6523 goto out;
6524 }
6525
6526out:
6527 error_propagate(errp, err);
6528}
6529
6530void visit_type_GICCapability(Visitor *v, const char *name, GICCapability **obj, Error **errp)
6531{
6532 Error *err = NULL;
6533
6534 visit_start_struct(v, name, (void **)obj, sizeof(GICCapability), &err);
6535 if (err) {
6536 goto out;
6537 }
6538 if (!*obj) {
6539 goto out_obj;
6540 }
6541 visit_type_GICCapability_members(v, *obj, &err);
6542 if (err) {
6543 goto out_obj;
6544 }
6545 visit_check_struct(v, &err);
6546out_obj:
6547 visit_end_struct(v, (void **)obj);
6548 if (err && visit_is_input(v)) {
6549 qapi_free_GICCapability(*obj);
6550 *obj = NULL;
6551 }
6552out:
6553 error_propagate(errp, err);
6554}
6555
6556void visit_type_GICCapabilityList(Visitor *v, const char *name, GICCapabilityList **obj, Error **errp)
6557{
6558 Error *err = NULL;
6559 GICCapabilityList *tail;
6560 size_t size = sizeof(**obj);
6561
6562 visit_start_list(v, name, (GenericList **)obj, size, &err);
6563 if (err) {
6564 goto out;
6565 }
6566
6567 for (tail = *obj; tail;
6568 tail = (GICCapabilityList *)visit_next_list(v, (GenericList *)tail, size)) {
6569 visit_type_GICCapability(v, NULL, &tail->value, &err);
6570 if (err) {
6571 break;
6572 }
6573 }
6574
6575 if (!err) {
6576 visit_check_list(v, &err);
6577 }
6578 visit_end_list(v, (void **)obj);
6579 if (err && visit_is_input(v)) {
6580 qapi_free_GICCapabilityList(*obj);
6581 *obj = NULL;
6582 }
6583out:
6584 error_propagate(errp, err);
6585}
6586
6587void visit_type_GuestPanicAction(Visitor *v, const char *name, GuestPanicAction *obj, Error **errp)
6588{
6589 int value = *obj;
6590 visit_type_enum(v, name, &value, GuestPanicAction_lookup, errp);
6591 *obj = value;
6592}
6593
6594void visit_type_GuestPanicInformation_members(Visitor *v, GuestPanicInformation *obj, Error **errp)
6595{
6596 Error *err = NULL;
6597
6598 visit_type_q_obj_GuestPanicInformation_base_members(v, (q_obj_GuestPanicInformation_base *)obj, &err);
6599 if (err) {
6600 goto out;
6601 }
6602 switch (obj->type) {
6603 case GUEST_PANIC_INFORMATION_TYPE_HYPER_V:
6604 visit_type_GuestPanicInformationHyperV_members(v, &obj->u.hyper_v, &err);
6605 break;
6606 default:
6607 abort();
6608 }
6609
6610out:
6611 error_propagate(errp, err);
6612}
6613
6614void visit_type_GuestPanicInformation(Visitor *v, const char *name, GuestPanicInformation **obj, Error **errp)
6615{
6616 Error *err = NULL;
6617
6618 visit_start_struct(v, name, (void **)obj, sizeof(GuestPanicInformation), &err);
6619 if (err) {
6620 goto out;
6621 }
6622 if (!*obj) {
6623 goto out_obj;
6624 }
6625 visit_type_GuestPanicInformation_members(v, *obj, &err);
6626 if (err) {
6627 goto out_obj;
6628 }
6629 visit_check_struct(v, &err);
6630out_obj:
6631 visit_end_struct(v, (void **)obj);
6632 if (err && visit_is_input(v)) {
6633 qapi_free_GuestPanicInformation(*obj);
6634 *obj = NULL;
6635 }
6636out:
6637 error_propagate(errp, err);
6638}
6639
6640void visit_type_GuestPanicInformationHyperV_members(Visitor *v, GuestPanicInformationHyperV *obj, Error **errp)
6641{
6642 Error *err = NULL;
6643
6644 visit_type_uint64(v, "arg1", &obj->arg1, &err);
6645 if (err) {
6646 goto out;
6647 }
6648 visit_type_uint64(v, "arg2", &obj->arg2, &err);
6649 if (err) {
6650 goto out;
6651 }
6652 visit_type_uint64(v, "arg3", &obj->arg3, &err);
6653 if (err) {
6654 goto out;
6655 }
6656 visit_type_uint64(v, "arg4", &obj->arg4, &err);
6657 if (err) {
6658 goto out;
6659 }
6660 visit_type_uint64(v, "arg5", &obj->arg5, &err);
6661 if (err) {
6662 goto out;
6663 }
6664
6665out:
6666 error_propagate(errp, err);
6667}
6668
6669void visit_type_GuestPanicInformationHyperV(Visitor *v, const char *name, GuestPanicInformationHyperV **obj, Error **errp)
6670{
6671 Error *err = NULL;
6672
6673 visit_start_struct(v, name, (void **)obj, sizeof(GuestPanicInformationHyperV), &err);
6674 if (err) {
6675 goto out;
6676 }
6677 if (!*obj) {
6678 goto out_obj;
6679 }
6680 visit_type_GuestPanicInformationHyperV_members(v, *obj, &err);
6681 if (err) {
6682 goto out_obj;
6683 }
6684 visit_check_struct(v, &err);
6685out_obj:
6686 visit_end_struct(v, (void **)obj);
6687 if (err && visit_is_input(v)) {
6688 qapi_free_GuestPanicInformationHyperV(*obj);
6689 *obj = NULL;
6690 }
6691out:
6692 error_propagate(errp, err);
6693}
6694
6695void visit_type_GuestPanicInformationType(Visitor *v, const char *name, GuestPanicInformationType *obj, Error **errp)
6696{
6697 int value = *obj;
6698 visit_type_enum(v, name, &value, GuestPanicInformationType_lookup, errp);
6699 *obj = value;
6700}
6701
6702void visit_type_GuidInfo_members(Visitor *v, GuidInfo *obj, Error **errp)
6703{
6704 Error *err = NULL;
6705
6706 visit_type_str(v, "guid", &obj->guid, &err);
6707 if (err) {
6708 goto out;
6709 }
6710
6711out:
6712 error_propagate(errp, err);
6713}
6714
6715void visit_type_GuidInfo(Visitor *v, const char *name, GuidInfo **obj, Error **errp)
6716{
6717 Error *err = NULL;
6718
6719 visit_start_struct(v, name, (void **)obj, sizeof(GuidInfo), &err);
6720 if (err) {
6721 goto out;
6722 }
6723 if (!*obj) {
6724 goto out_obj;
6725 }
6726 visit_type_GuidInfo_members(v, *obj, &err);
6727 if (err) {
6728 goto out_obj;
6729 }
6730 visit_check_struct(v, &err);
6731out_obj:
6732 visit_end_struct(v, (void **)obj);
6733 if (err && visit_is_input(v)) {
6734 qapi_free_GuidInfo(*obj);
6735 *obj = NULL;
6736 }
6737out:
6738 error_propagate(errp, err);
6739}
6740
6741void visit_type_HostMemPolicy(Visitor *v, const char *name, HostMemPolicy *obj, Error **errp)
6742{
6743 int value = *obj;
6744 visit_type_enum(v, name, &value, HostMemPolicy_lookup, errp);
6745 *obj = value;
6746}
6747
6748void visit_type_HotpluggableCPU_members(Visitor *v, HotpluggableCPU *obj, Error **errp)
6749{
6750 Error *err = NULL;
6751
6752 visit_type_str(v, "type", &obj->type, &err);
6753 if (err) {
6754 goto out;
6755 }
6756 visit_type_int(v, "vcpus-count", &obj->vcpus_count, &err);
6757 if (err) {
6758 goto out;
6759 }
6760 visit_type_CpuInstanceProperties(v, "props", &obj->props, &err);
6761 if (err) {
6762 goto out;
6763 }
6764 if (visit_optional(v, "qom-path", &obj->has_qom_path)) {
6765 visit_type_str(v, "qom-path", &obj->qom_path, &err);
6766 if (err) {
6767 goto out;
6768 }
6769 }
6770
6771out:
6772 error_propagate(errp, err);
6773}
6774
6775void visit_type_HotpluggableCPU(Visitor *v, const char *name, HotpluggableCPU **obj, Error **errp)
6776{
6777 Error *err = NULL;
6778
6779 visit_start_struct(v, name, (void **)obj, sizeof(HotpluggableCPU), &err);
6780 if (err) {
6781 goto out;
6782 }
6783 if (!*obj) {
6784 goto out_obj;
6785 }
6786 visit_type_HotpluggableCPU_members(v, *obj, &err);
6787 if (err) {
6788 goto out_obj;
6789 }
6790 visit_check_struct(v, &err);
6791out_obj:
6792 visit_end_struct(v, (void **)obj);
6793 if (err && visit_is_input(v)) {
6794 qapi_free_HotpluggableCPU(*obj);
6795 *obj = NULL;
6796 }
6797out:
6798 error_propagate(errp, err);
6799}
6800
6801void visit_type_HotpluggableCPUList(Visitor *v, const char *name, HotpluggableCPUList **obj, Error **errp)
6802{
6803 Error *err = NULL;
6804 HotpluggableCPUList *tail;
6805 size_t size = sizeof(**obj);
6806
6807 visit_start_list(v, name, (GenericList **)obj, size, &err);
6808 if (err) {
6809 goto out;
6810 }
6811
6812 for (tail = *obj; tail;
6813 tail = (HotpluggableCPUList *)visit_next_list(v, (GenericList *)tail, size)) {
6814 visit_type_HotpluggableCPU(v, NULL, &tail->value, &err);
6815 if (err) {
6816 break;
6817 }
6818 }
6819
6820 if (!err) {
6821 visit_check_list(v, &err);
6822 }
6823 visit_end_list(v, (void **)obj);
6824 if (err && visit_is_input(v)) {
6825 qapi_free_HotpluggableCPUList(*obj);
6826 *obj = NULL;
6827 }
6828out:
6829 error_propagate(errp, err);
6830}
6831
6832void visit_type_IOThreadInfo_members(Visitor *v, IOThreadInfo *obj, Error **errp)
6833{
6834 Error *err = NULL;
6835
6836 visit_type_str(v, "id", &obj->id, &err);
6837 if (err) {
6838 goto out;
6839 }
6840 visit_type_int(v, "thread-id", &obj->thread_id, &err);
6841 if (err) {
6842 goto out;
6843 }
6844 visit_type_int(v, "poll-max-ns", &obj->poll_max_ns, &err);
6845 if (err) {
6846 goto out;
6847 }
6848 visit_type_int(v, "poll-grow", &obj->poll_grow, &err);
6849 if (err) {
6850 goto out;
6851 }
6852 visit_type_int(v, "poll-shrink", &obj->poll_shrink, &err);
6853 if (err) {
6854 goto out;
6855 }
6856
6857out:
6858 error_propagate(errp, err);
6859}
6860
6861void visit_type_IOThreadInfo(Visitor *v, const char *name, IOThreadInfo **obj, Error **errp)
6862{
6863 Error *err = NULL;
6864
6865 visit_start_struct(v, name, (void **)obj, sizeof(IOThreadInfo), &err);
6866 if (err) {
6867 goto out;
6868 }
6869 if (!*obj) {
6870 goto out_obj;
6871 }
6872 visit_type_IOThreadInfo_members(v, *obj, &err);
6873 if (err) {
6874 goto out_obj;
6875 }
6876 visit_check_struct(v, &err);
6877out_obj:
6878 visit_end_struct(v, (void **)obj);
6879 if (err && visit_is_input(v)) {
6880 qapi_free_IOThreadInfo(*obj);
6881 *obj = NULL;
6882 }
6883out:
6884 error_propagate(errp, err);
6885}
6886
6887void visit_type_IOThreadInfoList(Visitor *v, const char *name, IOThreadInfoList **obj, Error **errp)
6888{
6889 Error *err = NULL;
6890 IOThreadInfoList *tail;
6891 size_t size = sizeof(**obj);
6892
6893 visit_start_list(v, name, (GenericList **)obj, size, &err);
6894 if (err) {
6895 goto out;
6896 }
6897
6898 for (tail = *obj; tail;
6899 tail = (IOThreadInfoList *)visit_next_list(v, (GenericList *)tail, size)) {
6900 visit_type_IOThreadInfo(v, NULL, &tail->value, &err);
6901 if (err) {
6902 break;
6903 }
6904 }
6905
6906 if (!err) {
6907 visit_check_list(v, &err);
6908 }
6909 visit_end_list(v, (void **)obj);
6910 if (err && visit_is_input(v)) {
6911 qapi_free_IOThreadInfoList(*obj);
6912 *obj = NULL;
6913 }
6914out:
6915 error_propagate(errp, err);
6916}
6917
6918void visit_type_ImageCheck_members(Visitor *v, ImageCheck *obj, Error **errp)
6919{
6920 Error *err = NULL;
6921
6922 visit_type_str(v, "filename", &obj->filename, &err);
6923 if (err) {
6924 goto out;
6925 }
6926 visit_type_str(v, "format", &obj->format, &err);
6927 if (err) {
6928 goto out;
6929 }
6930 visit_type_int(v, "check-errors", &obj->check_errors, &err);
6931 if (err) {
6932 goto out;
6933 }
6934 if (visit_optional(v, "image-end-offset", &obj->has_image_end_offset)) {
6935 visit_type_int(v, "image-end-offset", &obj->image_end_offset, &err);
6936 if (err) {
6937 goto out;
6938 }
6939 }
6940 if (visit_optional(v, "corruptions", &obj->has_corruptions)) {
6941 visit_type_int(v, "corruptions", &obj->corruptions, &err);
6942 if (err) {
6943 goto out;
6944 }
6945 }
6946 if (visit_optional(v, "leaks", &obj->has_leaks)) {
6947 visit_type_int(v, "leaks", &obj->leaks, &err);
6948 if (err) {
6949 goto out;
6950 }
6951 }
6952 if (visit_optional(v, "corruptions-fixed", &obj->has_corruptions_fixed)) {
6953 visit_type_int(v, "corruptions-fixed", &obj->corruptions_fixed, &err);
6954 if (err) {
6955 goto out;
6956 }
6957 }
6958 if (visit_optional(v, "leaks-fixed", &obj->has_leaks_fixed)) {
6959 visit_type_int(v, "leaks-fixed", &obj->leaks_fixed, &err);
6960 if (err) {
6961 goto out;
6962 }
6963 }
6964 if (visit_optional(v, "total-clusters", &obj->has_total_clusters)) {
6965 visit_type_int(v, "total-clusters", &obj->total_clusters, &err);
6966 if (err) {
6967 goto out;
6968 }
6969 }
6970 if (visit_optional(v, "allocated-clusters", &obj->has_allocated_clusters)) {
6971 visit_type_int(v, "allocated-clusters", &obj->allocated_clusters, &err);
6972 if (err) {
6973 goto out;
6974 }
6975 }
6976 if (visit_optional(v, "fragmented-clusters", &obj->has_fragmented_clusters)) {
6977 visit_type_int(v, "fragmented-clusters", &obj->fragmented_clusters, &err);
6978 if (err) {
6979 goto out;
6980 }
6981 }
6982 if (visit_optional(v, "compressed-clusters", &obj->has_compressed_clusters)) {
6983 visit_type_int(v, "compressed-clusters", &obj->compressed_clusters, &err);
6984 if (err) {
6985 goto out;
6986 }
6987 }
6988
6989out:
6990 error_propagate(errp, err);
6991}
6992
6993void visit_type_ImageCheck(Visitor *v, const char *name, ImageCheck **obj, Error **errp)
6994{
6995 Error *err = NULL;
6996
6997 visit_start_struct(v, name, (void **)obj, sizeof(ImageCheck), &err);
6998 if (err) {
6999 goto out;
7000 }
7001 if (!*obj) {
7002 goto out_obj;
7003 }
7004 visit_type_ImageCheck_members(v, *obj, &err);
7005 if (err) {
7006 goto out_obj;
7007 }
7008 visit_check_struct(v, &err);
7009out_obj:
7010 visit_end_struct(v, (void **)obj);
7011 if (err && visit_is_input(v)) {
7012 qapi_free_ImageCheck(*obj);
7013 *obj = NULL;
7014 }
7015out:
7016 error_propagate(errp, err);
7017}
7018
7019void visit_type_ImageInfo_members(Visitor *v, ImageInfo *obj, Error **errp)
7020{
7021 Error *err = NULL;
7022
7023 visit_type_str(v, "filename", &obj->filename, &err);
7024 if (err) {
7025 goto out;
7026 }
7027 visit_type_str(v, "format", &obj->format, &err);
7028 if (err) {
7029 goto out;
7030 }
7031 if (visit_optional(v, "dirty-flag", &obj->has_dirty_flag)) {
7032 visit_type_bool(v, "dirty-flag", &obj->dirty_flag, &err);
7033 if (err) {
7034 goto out;
7035 }
7036 }
7037 if (visit_optional(v, "actual-size", &obj->has_actual_size)) {
7038 visit_type_int(v, "actual-size", &obj->actual_size, &err);
7039 if (err) {
7040 goto out;
7041 }
7042 }
7043 visit_type_int(v, "virtual-size", &obj->virtual_size, &err);
7044 if (err) {
7045 goto out;
7046 }
7047 if (visit_optional(v, "cluster-size", &obj->has_cluster_size)) {
7048 visit_type_int(v, "cluster-size", &obj->cluster_size, &err);
7049 if (err) {
7050 goto out;
7051 }
7052 }
7053 if (visit_optional(v, "encrypted", &obj->has_encrypted)) {
7054 visit_type_bool(v, "encrypted", &obj->encrypted, &err);
7055 if (err) {
7056 goto out;
7057 }
7058 }
7059 if (visit_optional(v, "compressed", &obj->has_compressed)) {
7060 visit_type_bool(v, "compressed", &obj->compressed, &err);
7061 if (err) {
7062 goto out;
7063 }
7064 }
7065 if (visit_optional(v, "backing-filename", &obj->has_backing_filename)) {
7066 visit_type_str(v, "backing-filename", &obj->backing_filename, &err);
7067 if (err) {
7068 goto out;
7069 }
7070 }
7071 if (visit_optional(v, "full-backing-filename", &obj->has_full_backing_filename)) {
7072 visit_type_str(v, "full-backing-filename", &obj->full_backing_filename, &err);
7073 if (err) {
7074 goto out;
7075 }
7076 }
7077 if (visit_optional(v, "backing-filename-format", &obj->has_backing_filename_format)) {
7078 visit_type_str(v, "backing-filename-format", &obj->backing_filename_format, &err);
7079 if (err) {
7080 goto out;
7081 }
7082 }
7083 if (visit_optional(v, "snapshots", &obj->has_snapshots)) {
7084 visit_type_SnapshotInfoList(v, "snapshots", &obj->snapshots, &err);
7085 if (err) {
7086 goto out;
7087 }
7088 }
7089 if (visit_optional(v, "backing-image", &obj->has_backing_image)) {
7090 visit_type_ImageInfo(v, "backing-image", &obj->backing_image, &err);
7091 if (err) {
7092 goto out;
7093 }
7094 }
7095 if (visit_optional(v, "format-specific", &obj->has_format_specific)) {
7096 visit_type_ImageInfoSpecific(v, "format-specific", &obj->format_specific, &err);
7097 if (err) {
7098 goto out;
7099 }
7100 }
7101
7102out:
7103 error_propagate(errp, err);
7104}
7105
7106void visit_type_ImageInfo(Visitor *v, const char *name, ImageInfo **obj, Error **errp)
7107{
7108 Error *err = NULL;
7109
7110 visit_start_struct(v, name, (void **)obj, sizeof(ImageInfo), &err);
7111 if (err) {
7112 goto out;
7113 }
7114 if (!*obj) {
7115 goto out_obj;
7116 }
7117 visit_type_ImageInfo_members(v, *obj, &err);
7118 if (err) {
7119 goto out_obj;
7120 }
7121 visit_check_struct(v, &err);
7122out_obj:
7123 visit_end_struct(v, (void **)obj);
7124 if (err && visit_is_input(v)) {
7125 qapi_free_ImageInfo(*obj);
7126 *obj = NULL;
7127 }
7128out:
7129 error_propagate(errp, err);
7130}
7131
7132void visit_type_ImageInfoList(Visitor *v, const char *name, ImageInfoList **obj, Error **errp)
7133{
7134 Error *err = NULL;
7135 ImageInfoList *tail;
7136 size_t size = sizeof(**obj);
7137
7138 visit_start_list(v, name, (GenericList **)obj, size, &err);
7139 if (err) {
7140 goto out;
7141 }
7142
7143 for (tail = *obj; tail;
7144 tail = (ImageInfoList *)visit_next_list(v, (GenericList *)tail, size)) {
7145 visit_type_ImageInfo(v, NULL, &tail->value, &err);
7146 if (err) {
7147 break;
7148 }
7149 }
7150
7151 if (!err) {
7152 visit_check_list(v, &err);
7153 }
7154 visit_end_list(v, (void **)obj);
7155 if (err && visit_is_input(v)) {
7156 qapi_free_ImageInfoList(*obj);
7157 *obj = NULL;
7158 }
7159out:
7160 error_propagate(errp, err);
7161}
7162
7163void visit_type_ImageInfoSpecific_members(Visitor *v, ImageInfoSpecific *obj, Error **errp)
7164{
7165 Error *err = NULL;
7166
7167 visit_type_ImageInfoSpecificKind(v, "type", &obj->type, &err);
7168 if (err) {
7169 goto out;
7170 }
7171 switch (obj->type) {
7172 case IMAGE_INFO_SPECIFIC_KIND_QCOW2:
7173 visit_type_q_obj_ImageInfoSpecificQCow2_wrapper_members(v, &obj->u.qcow2, &err);
7174 break;
7175 case IMAGE_INFO_SPECIFIC_KIND_VMDK:
7176 visit_type_q_obj_ImageInfoSpecificVmdk_wrapper_members(v, &obj->u.vmdk, &err);
7177 break;
7178 case IMAGE_INFO_SPECIFIC_KIND_LUKS:
7179 visit_type_q_obj_QCryptoBlockInfoLUKS_wrapper_members(v, &obj->u.luks, &err);
7180 break;
7181 default:
7182 abort();
7183 }
7184
7185out:
7186 error_propagate(errp, err);
7187}
7188
7189void visit_type_ImageInfoSpecific(Visitor *v, const char *name, ImageInfoSpecific **obj, Error **errp)
7190{
7191 Error *err = NULL;
7192
7193 visit_start_struct(v, name, (void **)obj, sizeof(ImageInfoSpecific), &err);
7194 if (err) {
7195 goto out;
7196 }
7197 if (!*obj) {
7198 goto out_obj;
7199 }
7200 visit_type_ImageInfoSpecific_members(v, *obj, &err);
7201 if (err) {
7202 goto out_obj;
7203 }
7204 visit_check_struct(v, &err);
7205out_obj:
7206 visit_end_struct(v, (void **)obj);
7207 if (err && visit_is_input(v)) {
7208 qapi_free_ImageInfoSpecific(*obj);
7209 *obj = NULL;
7210 }
7211out:
7212 error_propagate(errp, err);
7213}
7214
7215void visit_type_ImageInfoSpecificKind(Visitor *v, const char *name, ImageInfoSpecificKind *obj, Error **errp)
7216{
7217 int value = *obj;
7218 visit_type_enum(v, name, &value, ImageInfoSpecificKind_lookup, errp);
7219 *obj = value;
7220}
7221
7222void visit_type_ImageInfoSpecificQCow2_members(Visitor *v, ImageInfoSpecificQCow2 *obj, Error **errp)
7223{
7224 Error *err = NULL;
7225
7226 visit_type_str(v, "compat", &obj->compat, &err);
7227 if (err) {
7228 goto out;
7229 }
7230 if (visit_optional(v, "lazy-refcounts", &obj->has_lazy_refcounts)) {
7231 visit_type_bool(v, "lazy-refcounts", &obj->lazy_refcounts, &err);
7232 if (err) {
7233 goto out;
7234 }
7235 }
7236 if (visit_optional(v, "corrupt", &obj->has_corrupt)) {
7237 visit_type_bool(v, "corrupt", &obj->corrupt, &err);
7238 if (err) {
7239 goto out;
7240 }
7241 }
7242 visit_type_int(v, "refcount-bits", &obj->refcount_bits, &err);
7243 if (err) {
7244 goto out;
7245 }
7246 if (visit_optional(v, "encrypt", &obj->has_encrypt)) {
7247 visit_type_ImageInfoSpecificQCow2Encryption(v, "encrypt", &obj->encrypt, &err);
7248 if (err) {
7249 goto out;
7250 }
7251 }
7252
7253out:
7254 error_propagate(errp, err);
7255}
7256
7257void visit_type_ImageInfoSpecificQCow2(Visitor *v, const char *name, ImageInfoSpecificQCow2 **obj, Error **errp)
7258{
7259 Error *err = NULL;
7260
7261 visit_start_struct(v, name, (void **)obj, sizeof(ImageInfoSpecificQCow2), &err);
7262 if (err) {
7263 goto out;
7264 }
7265 if (!*obj) {
7266 goto out_obj;
7267 }
7268 visit_type_ImageInfoSpecificQCow2_members(v, *obj, &err);
7269 if (err) {
7270 goto out_obj;
7271 }
7272 visit_check_struct(v, &err);
7273out_obj:
7274 visit_end_struct(v, (void **)obj);
7275 if (err && visit_is_input(v)) {
7276 qapi_free_ImageInfoSpecificQCow2(*obj);
7277 *obj = NULL;
7278 }
7279out:
7280 error_propagate(errp, err);
7281}
7282
7283void visit_type_ImageInfoSpecificQCow2Encryption_members(Visitor *v, ImageInfoSpecificQCow2Encryption *obj, Error **errp)
7284{
7285 Error *err = NULL;
7286
7287 visit_type_ImageInfoSpecificQCow2EncryptionBase_members(v, (ImageInfoSpecificQCow2EncryptionBase *)obj, &err);
7288 if (err) {
7289 goto out;
7290 }
7291 switch (obj->format) {
7292 case BLOCKDEV_QCOW2_ENCRYPTION_FORMAT_AES:
7293 visit_type_QCryptoBlockInfoQCow_members(v, &obj->u.aes, &err);
7294 break;
7295 case BLOCKDEV_QCOW2_ENCRYPTION_FORMAT_LUKS:
7296 visit_type_QCryptoBlockInfoLUKS_members(v, &obj->u.luks, &err);
7297 break;
7298 default:
7299 abort();
7300 }
7301
7302out:
7303 error_propagate(errp, err);
7304}
7305
7306void visit_type_ImageInfoSpecificQCow2Encryption(Visitor *v, const char *name, ImageInfoSpecificQCow2Encryption **obj, Error **errp)
7307{
7308 Error *err = NULL;
7309
7310 visit_start_struct(v, name, (void **)obj, sizeof(ImageInfoSpecificQCow2Encryption), &err);
7311 if (err) {
7312 goto out;
7313 }
7314 if (!*obj) {
7315 goto out_obj;
7316 }
7317 visit_type_ImageInfoSpecificQCow2Encryption_members(v, *obj, &err);
7318 if (err) {
7319 goto out_obj;
7320 }
7321 visit_check_struct(v, &err);
7322out_obj:
7323 visit_end_struct(v, (void **)obj);
7324 if (err && visit_is_input(v)) {
7325 qapi_free_ImageInfoSpecificQCow2Encryption(*obj);
7326 *obj = NULL;
7327 }
7328out:
7329 error_propagate(errp, err);
7330}
7331
7332void visit_type_ImageInfoSpecificQCow2EncryptionBase_members(Visitor *v, ImageInfoSpecificQCow2EncryptionBase *obj, Error **errp)
7333{
7334 Error *err = NULL;
7335
7336 visit_type_BlockdevQcow2EncryptionFormat(v, "format", &obj->format, &err);
7337 if (err) {
7338 goto out;
7339 }
7340
7341out:
7342 error_propagate(errp, err);
7343}
7344
7345void visit_type_ImageInfoSpecificQCow2EncryptionBase(Visitor *v, const char *name, ImageInfoSpecificQCow2EncryptionBase **obj, Error **errp)
7346{
7347 Error *err = NULL;
7348
7349 visit_start_struct(v, name, (void **)obj, sizeof(ImageInfoSpecificQCow2EncryptionBase), &err);
7350 if (err) {
7351 goto out;
7352 }
7353 if (!*obj) {
7354 goto out_obj;
7355 }
7356 visit_type_ImageInfoSpecificQCow2EncryptionBase_members(v, *obj, &err);
7357 if (err) {
7358 goto out_obj;
7359 }
7360 visit_check_struct(v, &err);
7361out_obj:
7362 visit_end_struct(v, (void **)obj);
7363 if (err && visit_is_input(v)) {
7364 qapi_free_ImageInfoSpecificQCow2EncryptionBase(*obj);
7365 *obj = NULL;
7366 }
7367out:
7368 error_propagate(errp, err);
7369}
7370
7371void visit_type_ImageInfoSpecificVmdk_members(Visitor *v, ImageInfoSpecificVmdk *obj, Error **errp)
7372{
7373 Error *err = NULL;
7374
7375 visit_type_str(v, "create-type", &obj->create_type, &err);
7376 if (err) {
7377 goto out;
7378 }
7379 visit_type_int(v, "cid", &obj->cid, &err);
7380 if (err) {
7381 goto out;
7382 }
7383 visit_type_int(v, "parent-cid", &obj->parent_cid, &err);
7384 if (err) {
7385 goto out;
7386 }
7387 visit_type_ImageInfoList(v, "extents", &obj->extents, &err);
7388 if (err) {
7389 goto out;
7390 }
7391
7392out:
7393 error_propagate(errp, err);
7394}
7395
7396void visit_type_ImageInfoSpecificVmdk(Visitor *v, const char *name, ImageInfoSpecificVmdk **obj, Error **errp)
7397{
7398 Error *err = NULL;
7399
7400 visit_start_struct(v, name, (void **)obj, sizeof(ImageInfoSpecificVmdk), &err);
7401 if (err) {
7402 goto out;
7403 }
7404 if (!*obj) {
7405 goto out_obj;
7406 }
7407 visit_type_ImageInfoSpecificVmdk_members(v, *obj, &err);
7408 if (err) {
7409 goto out_obj;
7410 }
7411 visit_check_struct(v, &err);
7412out_obj:
7413 visit_end_struct(v, (void **)obj);
7414 if (err && visit_is_input(v)) {
7415 qapi_free_ImageInfoSpecificVmdk(*obj);
7416 *obj = NULL;
7417 }
7418out:
7419 error_propagate(errp, err);
7420}
7421
7422void visit_type_InetSocketAddress_members(Visitor *v, InetSocketAddress *obj, Error **errp)
7423{
7424 Error *err = NULL;
7425
7426 visit_type_InetSocketAddressBase_members(v, (InetSocketAddressBase *)obj, &err);
7427 if (err) {
7428 goto out;
7429 }
7430 if (visit_optional(v, "numeric", &obj->has_numeric)) {
7431 visit_type_bool(v, "numeric", &obj->numeric, &err);
7432 if (err) {
7433 goto out;
7434 }
7435 }
7436 if (visit_optional(v, "to", &obj->has_to)) {
7437 visit_type_uint16(v, "to", &obj->to, &err);
7438 if (err) {
7439 goto out;
7440 }
7441 }
7442 if (visit_optional(v, "ipv4", &obj->has_ipv4)) {
7443 visit_type_bool(v, "ipv4", &obj->ipv4, &err);
7444 if (err) {
7445 goto out;
7446 }
7447 }
7448 if (visit_optional(v, "ipv6", &obj->has_ipv6)) {
7449 visit_type_bool(v, "ipv6", &obj->ipv6, &err);
7450 if (err) {
7451 goto out;
7452 }
7453 }
7454
7455out:
7456 error_propagate(errp, err);
7457}
7458
7459void visit_type_InetSocketAddress(Visitor *v, const char *name, InetSocketAddress **obj, Error **errp)
7460{
7461 Error *err = NULL;
7462
7463 visit_start_struct(v, name, (void **)obj, sizeof(InetSocketAddress), &err);
7464 if (err) {
7465 goto out;
7466 }
7467 if (!*obj) {
7468 goto out_obj;
7469 }
7470 visit_type_InetSocketAddress_members(v, *obj, &err);
7471 if (err) {
7472 goto out_obj;
7473 }
7474 visit_check_struct(v, &err);
7475out_obj:
7476 visit_end_struct(v, (void **)obj);
7477 if (err && visit_is_input(v)) {
7478 qapi_free_InetSocketAddress(*obj);
7479 *obj = NULL;
7480 }
7481out:
7482 error_propagate(errp, err);
7483}
7484
7485void visit_type_InetSocketAddressBase_members(Visitor *v, InetSocketAddressBase *obj, Error **errp)
7486{
7487 Error *err = NULL;
7488
7489 visit_type_str(v, "host", &obj->host, &err);
7490 if (err) {
7491 goto out;
7492 }
7493 visit_type_str(v, "port", &obj->port, &err);
7494 if (err) {
7495 goto out;
7496 }
7497
7498out:
7499 error_propagate(errp, err);
7500}
7501
7502void visit_type_InetSocketAddressBase(Visitor *v, const char *name, InetSocketAddressBase **obj, Error **errp)
7503{
7504 Error *err = NULL;
7505
7506 visit_start_struct(v, name, (void **)obj, sizeof(InetSocketAddressBase), &err);
7507 if (err) {
7508 goto out;
7509 }
7510 if (!*obj) {
7511 goto out_obj;
7512 }
7513 visit_type_InetSocketAddressBase_members(v, *obj, &err);
7514 if (err) {
7515 goto out_obj;
7516 }
7517 visit_check_struct(v, &err);
7518out_obj:
7519 visit_end_struct(v, (void **)obj);
7520 if (err && visit_is_input(v)) {
7521 qapi_free_InetSocketAddressBase(*obj);
7522 *obj = NULL;
7523 }
7524out:
7525 error_propagate(errp, err);
7526}
7527
7528void visit_type_InetSocketAddressBaseList(Visitor *v, const char *name, InetSocketAddressBaseList **obj, Error **errp)
7529{
7530 Error *err = NULL;
7531 InetSocketAddressBaseList *tail;
7532 size_t size = sizeof(**obj);
7533
7534 visit_start_list(v, name, (GenericList **)obj, size, &err);
7535 if (err) {
7536 goto out;
7537 }
7538
7539 for (tail = *obj; tail;
7540 tail = (InetSocketAddressBaseList *)visit_next_list(v, (GenericList *)tail, size)) {
7541 visit_type_InetSocketAddressBase(v, NULL, &tail->value, &err);
7542 if (err) {
7543 break;
7544 }
7545 }
7546
7547 if (!err) {
7548 visit_check_list(v, &err);
7549 }
7550 visit_end_list(v, (void **)obj);
7551 if (err && visit_is_input(v)) {
7552 qapi_free_InetSocketAddressBaseList(*obj);
7553 *obj = NULL;
7554 }
7555out:
7556 error_propagate(errp, err);
7557}
7558
7559void visit_type_InputAxis(Visitor *v, const char *name, InputAxis *obj, Error **errp)
7560{
7561 int value = *obj;
7562 visit_type_enum(v, name, &value, InputAxis_lookup, errp);
7563 *obj = value;
7564}
7565
7566void visit_type_InputBtnEvent_members(Visitor *v, InputBtnEvent *obj, Error **errp)
7567{
7568 Error *err = NULL;
7569
7570 visit_type_InputButton(v, "button", &obj->button, &err);
7571 if (err) {
7572 goto out;
7573 }
7574 visit_type_bool(v, "down", &obj->down, &err);
7575 if (err) {
7576 goto out;
7577 }
7578
7579out:
7580 error_propagate(errp, err);
7581}
7582
7583void visit_type_InputBtnEvent(Visitor *v, const char *name, InputBtnEvent **obj, Error **errp)
7584{
7585 Error *err = NULL;
7586
7587 visit_start_struct(v, name, (void **)obj, sizeof(InputBtnEvent), &err);
7588 if (err) {
7589 goto out;
7590 }
7591 if (!*obj) {
7592 goto out_obj;
7593 }
7594 visit_type_InputBtnEvent_members(v, *obj, &err);
7595 if (err) {
7596 goto out_obj;
7597 }
7598 visit_check_struct(v, &err);
7599out_obj:
7600 visit_end_struct(v, (void **)obj);
7601 if (err && visit_is_input(v)) {
7602 qapi_free_InputBtnEvent(*obj);
7603 *obj = NULL;
7604 }
7605out:
7606 error_propagate(errp, err);
7607}
7608
7609void visit_type_InputButton(Visitor *v, const char *name, InputButton *obj, Error **errp)
7610{
7611 int value = *obj;
7612 visit_type_enum(v, name, &value, InputButton_lookup, errp);
7613 *obj = value;
7614}
7615
7616void visit_type_InputEvent_members(Visitor *v, InputEvent *obj, Error **errp)
7617{
7618 Error *err = NULL;
7619
7620 visit_type_InputEventKind(v, "type", &obj->type, &err);
7621 if (err) {
7622 goto out;
7623 }
7624 switch (obj->type) {
7625 case INPUT_EVENT_KIND_KEY:
7626 visit_type_q_obj_InputKeyEvent_wrapper_members(v, &obj->u.key, &err);
7627 break;
7628 case INPUT_EVENT_KIND_BTN:
7629 visit_type_q_obj_InputBtnEvent_wrapper_members(v, &obj->u.btn, &err);
7630 break;
7631 case INPUT_EVENT_KIND_REL:
7632 visit_type_q_obj_InputMoveEvent_wrapper_members(v, &obj->u.rel, &err);
7633 break;
7634 case INPUT_EVENT_KIND_ABS:
7635 visit_type_q_obj_InputMoveEvent_wrapper_members(v, &obj->u.abs, &err);
7636 break;
7637 default:
7638 abort();
7639 }
7640
7641out:
7642 error_propagate(errp, err);
7643}
7644
7645void visit_type_InputEvent(Visitor *v, const char *name, InputEvent **obj, Error **errp)
7646{
7647 Error *err = NULL;
7648
7649 visit_start_struct(v, name, (void **)obj, sizeof(InputEvent), &err);
7650 if (err) {
7651 goto out;
7652 }
7653 if (!*obj) {
7654 goto out_obj;
7655 }
7656 visit_type_InputEvent_members(v, *obj, &err);
7657 if (err) {
7658 goto out_obj;
7659 }
7660 visit_check_struct(v, &err);
7661out_obj:
7662 visit_end_struct(v, (void **)obj);
7663 if (err && visit_is_input(v)) {
7664 qapi_free_InputEvent(*obj);
7665 *obj = NULL;
7666 }
7667out:
7668 error_propagate(errp, err);
7669}
7670
7671void visit_type_InputEventKind(Visitor *v, const char *name, InputEventKind *obj, Error **errp)
7672{
7673 int value = *obj;
7674 visit_type_enum(v, name, &value, InputEventKind_lookup, errp);
7675 *obj = value;
7676}
7677
7678void visit_type_InputEventList(Visitor *v, const char *name, InputEventList **obj, Error **errp)
7679{
7680 Error *err = NULL;
7681 InputEventList *tail;
7682 size_t size = sizeof(**obj);
7683
7684 visit_start_list(v, name, (GenericList **)obj, size, &err);
7685 if (err) {
7686 goto out;
7687 }
7688
7689 for (tail = *obj; tail;
7690 tail = (InputEventList *)visit_next_list(v, (GenericList *)tail, size)) {
7691 visit_type_InputEvent(v, NULL, &tail->value, &err);
7692 if (err) {
7693 break;
7694 }
7695 }
7696
7697 if (!err) {
7698 visit_check_list(v, &err);
7699 }
7700 visit_end_list(v, (void **)obj);
7701 if (err && visit_is_input(v)) {
7702 qapi_free_InputEventList(*obj);
7703 *obj = NULL;
7704 }
7705out:
7706 error_propagate(errp, err);
7707}
7708
7709void visit_type_InputKeyEvent_members(Visitor *v, InputKeyEvent *obj, Error **errp)
7710{
7711 Error *err = NULL;
7712
7713 visit_type_KeyValue(v, "key", &obj->key, &err);
7714 if (err) {
7715 goto out;
7716 }
7717 visit_type_bool(v, "down", &obj->down, &err);
7718 if (err) {
7719 goto out;
7720 }
7721
7722out:
7723 error_propagate(errp, err);
7724}
7725
7726void visit_type_InputKeyEvent(Visitor *v, const char *name, InputKeyEvent **obj, Error **errp)
7727{
7728 Error *err = NULL;
7729
7730 visit_start_struct(v, name, (void **)obj, sizeof(InputKeyEvent), &err);
7731 if (err) {
7732 goto out;
7733 }
7734 if (!*obj) {
7735 goto out_obj;
7736 }
7737 visit_type_InputKeyEvent_members(v, *obj, &err);
7738 if (err) {
7739 goto out_obj;
7740 }
7741 visit_check_struct(v, &err);
7742out_obj:
7743 visit_end_struct(v, (void **)obj);
7744 if (err && visit_is_input(v)) {
7745 qapi_free_InputKeyEvent(*obj);
7746 *obj = NULL;
7747 }
7748out:
7749 error_propagate(errp, err);
7750}
7751
7752void visit_type_InputMoveEvent_members(Visitor *v, InputMoveEvent *obj, Error **errp)
7753{
7754 Error *err = NULL;
7755
7756 visit_type_InputAxis(v, "axis", &obj->axis, &err);
7757 if (err) {
7758 goto out;
7759 }
7760 visit_type_int(v, "value", &obj->value, &err);
7761 if (err) {
7762 goto out;
7763 }
7764
7765out:
7766 error_propagate(errp, err);
7767}
7768
7769void visit_type_InputMoveEvent(Visitor *v, const char *name, InputMoveEvent **obj, Error **errp)
7770{
7771 Error *err = NULL;
7772
7773 visit_start_struct(v, name, (void **)obj, sizeof(InputMoveEvent), &err);
7774 if (err) {
7775 goto out;
7776 }
7777 if (!*obj) {
7778 goto out_obj;
7779 }
7780 visit_type_InputMoveEvent_members(v, *obj, &err);
7781 if (err) {
7782 goto out_obj;
7783 }
7784 visit_check_struct(v, &err);
7785out_obj:
7786 visit_end_struct(v, (void **)obj);
7787 if (err && visit_is_input(v)) {
7788 qapi_free_InputMoveEvent(*obj);
7789 *obj = NULL;
7790 }
7791out:
7792 error_propagate(errp, err);
7793}
7794
7795void visit_type_IoOperationType(Visitor *v, const char *name, IoOperationType *obj, Error **errp)
7796{
7797 int value = *obj;
7798 visit_type_enum(v, name, &value, IoOperationType_lookup, errp);
7799 *obj = value;
7800}
7801
7802void visit_type_IscsiHeaderDigest(Visitor *v, const char *name, IscsiHeaderDigest *obj, Error **errp)
7803{
7804 int value = *obj;
7805 visit_type_enum(v, name, &value, IscsiHeaderDigest_lookup, errp);
7806 *obj = value;
7807}
7808
7809void visit_type_IscsiTransport(Visitor *v, const char *name, IscsiTransport *obj, Error **errp)
7810{
7811 int value = *obj;
7812 visit_type_enum(v, name, &value, IscsiTransport_lookup, errp);
7813 *obj = value;
7814}
7815
7816void visit_type_JSONType(Visitor *v, const char *name, JSONType *obj, Error **errp)
7817{
7818 int value = *obj;
7819 visit_type_enum(v, name, &value, JSONType_lookup, errp);
7820 *obj = value;
7821}
7822
7823void visit_type_KeyValue_members(Visitor *v, KeyValue *obj, Error **errp)
7824{
7825 Error *err = NULL;
7826
7827 visit_type_KeyValueKind(v, "type", &obj->type, &err);
7828 if (err) {
7829 goto out;
7830 }
7831 switch (obj->type) {
7832 case KEY_VALUE_KIND_NUMBER:
7833 visit_type_q_obj_int_wrapper_members(v, &obj->u.number, &err);
7834 break;
7835 case KEY_VALUE_KIND_QCODE:
7836 visit_type_q_obj_QKeyCode_wrapper_members(v, &obj->u.qcode, &err);
7837 break;
7838 default:
7839 abort();
7840 }
7841
7842out:
7843 error_propagate(errp, err);
7844}
7845
7846void visit_type_KeyValue(Visitor *v, const char *name, KeyValue **obj, Error **errp)
7847{
7848 Error *err = NULL;
7849
7850 visit_start_struct(v, name, (void **)obj, sizeof(KeyValue), &err);
7851 if (err) {
7852 goto out;
7853 }
7854 if (!*obj) {
7855 goto out_obj;
7856 }
7857 visit_type_KeyValue_members(v, *obj, &err);
7858 if (err) {
7859 goto out_obj;
7860 }
7861 visit_check_struct(v, &err);
7862out_obj:
7863 visit_end_struct(v, (void **)obj);
7864 if (err && visit_is_input(v)) {
7865 qapi_free_KeyValue(*obj);
7866 *obj = NULL;
7867 }
7868out:
7869 error_propagate(errp, err);
7870}
7871
7872void visit_type_KeyValueKind(Visitor *v, const char *name, KeyValueKind *obj, Error **errp)
7873{
7874 int value = *obj;
7875 visit_type_enum(v, name, &value, KeyValueKind_lookup, errp);
7876 *obj = value;
7877}
7878
7879void visit_type_KeyValueList(Visitor *v, const char *name, KeyValueList **obj, Error **errp)
7880{
7881 Error *err = NULL;
7882 KeyValueList *tail;
7883 size_t size = sizeof(**obj);
7884
7885 visit_start_list(v, name, (GenericList **)obj, size, &err);
7886 if (err) {
7887 goto out;
7888 }
7889
7890 for (tail = *obj; tail;
7891 tail = (KeyValueList *)visit_next_list(v, (GenericList *)tail, size)) {
7892 visit_type_KeyValue(v, NULL, &tail->value, &err);
7893 if (err) {
7894 break;
7895 }
7896 }
7897
7898 if (!err) {
7899 visit_check_list(v, &err);
7900 }
7901 visit_end_list(v, (void **)obj);
7902 if (err && visit_is_input(v)) {
7903 qapi_free_KeyValueList(*obj);
7904 *obj = NULL;
7905 }
7906out:
7907 error_propagate(errp, err);
7908}
7909
7910void visit_type_KvmInfo_members(Visitor *v, KvmInfo *obj, Error **errp)
7911{
7912 Error *err = NULL;
7913
7914 visit_type_bool(v, "enabled", &obj->enabled, &err);
7915 if (err) {
7916 goto out;
7917 }
7918 visit_type_bool(v, "present", &obj->present, &err);
7919 if (err) {
7920 goto out;
7921 }
7922
7923out:
7924 error_propagate(errp, err);
7925}
7926
7927void visit_type_KvmInfo(Visitor *v, const char *name, KvmInfo **obj, Error **errp)
7928{
7929 Error *err = NULL;
7930
7931 visit_start_struct(v, name, (void **)obj, sizeof(KvmInfo), &err);
7932 if (err) {
7933 goto out;
7934 }
7935 if (!*obj) {
7936 goto out_obj;
7937 }
7938 visit_type_KvmInfo_members(v, *obj, &err);
7939 if (err) {
7940 goto out_obj;
7941 }
7942 visit_check_struct(v, &err);
7943out_obj:
7944 visit_end_struct(v, (void **)obj);
7945 if (err && visit_is_input(v)) {
7946 qapi_free_KvmInfo(*obj);
7947 *obj = NULL;
7948 }
7949out:
7950 error_propagate(errp, err);
7951}
7952
7953void visit_type_LostTickPolicy(Visitor *v, const char *name, LostTickPolicy *obj, Error **errp)
7954{
7955 int value = *obj;
7956 visit_type_enum(v, name, &value, LostTickPolicy_lookup, errp);
7957 *obj = value;
7958}
7959
7960void visit_type_MachineInfo_members(Visitor *v, MachineInfo *obj, Error **errp)
7961{
7962 Error *err = NULL;
7963
7964 visit_type_str(v, "name", &obj->name, &err);
7965 if (err) {
7966 goto out;
7967 }
7968 if (visit_optional(v, "alias", &obj->has_alias)) {
7969 visit_type_str(v, "alias", &obj->alias, &err);
7970 if (err) {
7971 goto out;
7972 }
7973 }
7974 if (visit_optional(v, "is-default", &obj->has_is_default)) {
7975 visit_type_bool(v, "is-default", &obj->is_default, &err);
7976 if (err) {
7977 goto out;
7978 }
7979 }
7980 visit_type_int(v, "cpu-max", &obj->cpu_max, &err);
7981 if (err) {
7982 goto out;
7983 }
7984 visit_type_bool(v, "hotpluggable-cpus", &obj->hotpluggable_cpus, &err);
7985 if (err) {
7986 goto out;
7987 }
7988
7989out:
7990 error_propagate(errp, err);
7991}
7992
7993void visit_type_MachineInfo(Visitor *v, const char *name, MachineInfo **obj, Error **errp)
7994{
7995 Error *err = NULL;
7996
7997 visit_start_struct(v, name, (void **)obj, sizeof(MachineInfo), &err);
7998 if (err) {
7999 goto out;
8000 }
8001 if (!*obj) {
8002 goto out_obj;
8003 }
8004 visit_type_MachineInfo_members(v, *obj, &err);
8005 if (err) {
8006 goto out_obj;
8007 }
8008 visit_check_struct(v, &err);
8009out_obj:
8010 visit_end_struct(v, (void **)obj);
8011 if (err && visit_is_input(v)) {
8012 qapi_free_MachineInfo(*obj);
8013 *obj = NULL;
8014 }
8015out:
8016 error_propagate(errp, err);
8017}
8018
8019void visit_type_MachineInfoList(Visitor *v, const char *name, MachineInfoList **obj, Error **errp)
8020{
8021 Error *err = NULL;
8022 MachineInfoList *tail;
8023 size_t size = sizeof(**obj);
8024
8025 visit_start_list(v, name, (GenericList **)obj, size, &err);
8026 if (err) {
8027 goto out;
8028 }
8029
8030 for (tail = *obj; tail;
8031 tail = (MachineInfoList *)visit_next_list(v, (GenericList *)tail, size)) {
8032 visit_type_MachineInfo(v, NULL, &tail->value, &err);
8033 if (err) {
8034 break;
8035 }
8036 }
8037
8038 if (!err) {
8039 visit_check_list(v, &err);
8040 }
8041 visit_end_list(v, (void **)obj);
8042 if (err && visit_is_input(v)) {
8043 qapi_free_MachineInfoList(*obj);
8044 *obj = NULL;
8045 }
8046out:
8047 error_propagate(errp, err);
8048}
8049
8050void visit_type_MapEntry_members(Visitor *v, MapEntry *obj, Error **errp)
8051{
8052 Error *err = NULL;
8053
8054 visit_type_int(v, "start", &obj->start, &err);
8055 if (err) {
8056 goto out;
8057 }
8058 visit_type_int(v, "length", &obj->length, &err);
8059 if (err) {
8060 goto out;
8061 }
8062 visit_type_bool(v, "data", &obj->data, &err);
8063 if (err) {
8064 goto out;
8065 }
8066 visit_type_bool(v, "zero", &obj->zero, &err);
8067 if (err) {
8068 goto out;
8069 }
8070 visit_type_int(v, "depth", &obj->depth, &err);
8071 if (err) {
8072 goto out;
8073 }
8074 if (visit_optional(v, "offset", &obj->has_offset)) {
8075 visit_type_int(v, "offset", &obj->offset, &err);
8076 if (err) {
8077 goto out;
8078 }
8079 }
8080 if (visit_optional(v, "filename", &obj->has_filename)) {
8081 visit_type_str(v, "filename", &obj->filename, &err);
8082 if (err) {
8083 goto out;
8084 }
8085 }
8086
8087out:
8088 error_propagate(errp, err);
8089}
8090
8091void visit_type_MapEntry(Visitor *v, const char *name, MapEntry **obj, Error **errp)
8092{
8093 Error *err = NULL;
8094
8095 visit_start_struct(v, name, (void **)obj, sizeof(MapEntry), &err);
8096 if (err) {
8097 goto out;
8098 }
8099 if (!*obj) {
8100 goto out_obj;
8101 }
8102 visit_type_MapEntry_members(v, *obj, &err);
8103 if (err) {
8104 goto out_obj;
8105 }
8106 visit_check_struct(v, &err);
8107out_obj:
8108 visit_end_struct(v, (void **)obj);
8109 if (err && visit_is_input(v)) {
8110 qapi_free_MapEntry(*obj);
8111 *obj = NULL;
8112 }
8113out:
8114 error_propagate(errp, err);
8115}
8116
8117void visit_type_Memdev_members(Visitor *v, Memdev *obj, Error **errp)
8118{
8119 Error *err = NULL;
8120
8121 if (visit_optional(v, "id", &obj->has_id)) {
8122 visit_type_str(v, "id", &obj->id, &err);
8123 if (err) {
8124 goto out;
8125 }
8126 }
8127 visit_type_size(v, "size", &obj->size, &err);
8128 if (err) {
8129 goto out;
8130 }
8131 visit_type_bool(v, "merge", &obj->merge, &err);
8132 if (err) {
8133 goto out;
8134 }
8135 visit_type_bool(v, "dump", &obj->dump, &err);
8136 if (err) {
8137 goto out;
8138 }
8139 visit_type_bool(v, "prealloc", &obj->prealloc, &err);
8140 if (err) {
8141 goto out;
8142 }
8143 visit_type_uint16List(v, "host-nodes", &obj->host_nodes, &err);
8144 if (err) {
8145 goto out;
8146 }
8147 visit_type_HostMemPolicy(v, "policy", &obj->policy, &err);
8148 if (err) {
8149 goto out;
8150 }
8151
8152out:
8153 error_propagate(errp, err);
8154}
8155
8156void visit_type_Memdev(Visitor *v, const char *name, Memdev **obj, Error **errp)
8157{
8158 Error *err = NULL;
8159
8160 visit_start_struct(v, name, (void **)obj, sizeof(Memdev), &err);
8161 if (err) {
8162 goto out;
8163 }
8164 if (!*obj) {
8165 goto out_obj;
8166 }
8167 visit_type_Memdev_members(v, *obj, &err);
8168 if (err) {
8169 goto out_obj;
8170 }
8171 visit_check_struct(v, &err);
8172out_obj:
8173 visit_end_struct(v, (void **)obj);
8174 if (err && visit_is_input(v)) {
8175 qapi_free_Memdev(*obj);
8176 *obj = NULL;
8177 }
8178out:
8179 error_propagate(errp, err);
8180}
8181
8182void visit_type_MemdevList(Visitor *v, const char *name, MemdevList **obj, Error **errp)
8183{
8184 Error *err = NULL;
8185 MemdevList *tail;
8186 size_t size = sizeof(**obj);
8187
8188 visit_start_list(v, name, (GenericList **)obj, size, &err);
8189 if (err) {
8190 goto out;
8191 }
8192
8193 for (tail = *obj; tail;
8194 tail = (MemdevList *)visit_next_list(v, (GenericList *)tail, size)) {
8195 visit_type_Memdev(v, NULL, &tail->value, &err);
8196 if (err) {
8197 break;
8198 }
8199 }
8200
8201 if (!err) {
8202 visit_check_list(v, &err);
8203 }
8204 visit_end_list(v, (void **)obj);
8205 if (err && visit_is_input(v)) {
8206 qapi_free_MemdevList(*obj);
8207 *obj = NULL;
8208 }
8209out:
8210 error_propagate(errp, err);
8211}
8212
8213void visit_type_MemoryDeviceInfo_members(Visitor *v, MemoryDeviceInfo *obj, Error **errp)
8214{
8215 Error *err = NULL;
8216
8217 visit_type_MemoryDeviceInfoKind(v, "type", &obj->type, &err);
8218 if (err) {
8219 goto out;
8220 }
8221 switch (obj->type) {
8222 case MEMORY_DEVICE_INFO_KIND_DIMM:
8223 visit_type_q_obj_PCDIMMDeviceInfo_wrapper_members(v, &obj->u.dimm, &err);
8224 break;
8225 default:
8226 abort();
8227 }
8228
8229out:
8230 error_propagate(errp, err);
8231}
8232
8233void visit_type_MemoryDeviceInfo(Visitor *v, const char *name, MemoryDeviceInfo **obj, Error **errp)
8234{
8235 Error *err = NULL;
8236
8237 visit_start_struct(v, name, (void **)obj, sizeof(MemoryDeviceInfo), &err);
8238 if (err) {
8239 goto out;
8240 }
8241 if (!*obj) {
8242 goto out_obj;
8243 }
8244 visit_type_MemoryDeviceInfo_members(v, *obj, &err);
8245 if (err) {
8246 goto out_obj;
8247 }
8248 visit_check_struct(v, &err);
8249out_obj:
8250 visit_end_struct(v, (void **)obj);
8251 if (err && visit_is_input(v)) {
8252 qapi_free_MemoryDeviceInfo(*obj);
8253 *obj = NULL;
8254 }
8255out:
8256 error_propagate(errp, err);
8257}
8258
8259void visit_type_MemoryDeviceInfoKind(Visitor *v, const char *name, MemoryDeviceInfoKind *obj, Error **errp)
8260{
8261 int value = *obj;
8262 visit_type_enum(v, name, &value, MemoryDeviceInfoKind_lookup, errp);
8263 *obj = value;
8264}
8265
8266void visit_type_MemoryDeviceInfoList(Visitor *v, const char *name, MemoryDeviceInfoList **obj, Error **errp)
8267{
8268 Error *err = NULL;
8269 MemoryDeviceInfoList *tail;
8270 size_t size = sizeof(**obj);
8271
8272 visit_start_list(v, name, (GenericList **)obj, size, &err);
8273 if (err) {
8274 goto out;
8275 }
8276
8277 for (tail = *obj; tail;
8278 tail = (MemoryDeviceInfoList *)visit_next_list(v, (GenericList *)tail, size)) {
8279 visit_type_MemoryDeviceInfo(v, NULL, &tail->value, &err);
8280 if (err) {
8281 break;
8282 }
8283 }
8284
8285 if (!err) {
8286 visit_check_list(v, &err);
8287 }
8288 visit_end_list(v, (void **)obj);
8289 if (err && visit_is_input(v)) {
8290 qapi_free_MemoryDeviceInfoList(*obj);
8291 *obj = NULL;
8292 }
8293out:
8294 error_propagate(errp, err);
8295}
8296
8297void visit_type_MigrateSetParameters_members(Visitor *v, MigrateSetParameters *obj, Error **errp)
8298{
8299 Error *err = NULL;
8300
8301 if (visit_optional(v, "compress-level", &obj->has_compress_level)) {
8302 visit_type_int(v, "compress-level", &obj->compress_level, &err);
8303 if (err) {
8304 goto out;
8305 }
8306 }
8307 if (visit_optional(v, "compress-threads", &obj->has_compress_threads)) {
8308 visit_type_int(v, "compress-threads", &obj->compress_threads, &err);
8309 if (err) {
8310 goto out;
8311 }
8312 }
8313 if (visit_optional(v, "decompress-threads", &obj->has_decompress_threads)) {
8314 visit_type_int(v, "decompress-threads", &obj->decompress_threads, &err);
8315 if (err) {
8316 goto out;
8317 }
8318 }
8319 if (visit_optional(v, "cpu-throttle-initial", &obj->has_cpu_throttle_initial)) {
8320 visit_type_int(v, "cpu-throttle-initial", &obj->cpu_throttle_initial, &err);
8321 if (err) {
8322 goto out;
8323 }
8324 }
8325 if (visit_optional(v, "cpu-throttle-increment", &obj->has_cpu_throttle_increment)) {
8326 visit_type_int(v, "cpu-throttle-increment", &obj->cpu_throttle_increment, &err);
8327 if (err) {
8328 goto out;
8329 }
8330 }
8331 if (visit_optional(v, "tls-creds", &obj->has_tls_creds)) {
8332 visit_type_StrOrNull(v, "tls-creds", &obj->tls_creds, &err);
8333 if (err) {
8334 goto out;
8335 }
8336 }
8337 if (visit_optional(v, "tls-hostname", &obj->has_tls_hostname)) {
8338 visit_type_StrOrNull(v, "tls-hostname", &obj->tls_hostname, &err);
8339 if (err) {
8340 goto out;
8341 }
8342 }
8343 if (visit_optional(v, "max-bandwidth", &obj->has_max_bandwidth)) {
8344 visit_type_int(v, "max-bandwidth", &obj->max_bandwidth, &err);
8345 if (err) {
8346 goto out;
8347 }
8348 }
8349 if (visit_optional(v, "downtime-limit", &obj->has_downtime_limit)) {
8350 visit_type_int(v, "downtime-limit", &obj->downtime_limit, &err);
8351 if (err) {
8352 goto out;
8353 }
8354 }
8355 if (visit_optional(v, "x-checkpoint-delay", &obj->has_x_checkpoint_delay)) {
8356 visit_type_int(v, "x-checkpoint-delay", &obj->x_checkpoint_delay, &err);
8357 if (err) {
8358 goto out;
8359 }
8360 }
8361 if (visit_optional(v, "block-incremental", &obj->has_block_incremental)) {
8362 visit_type_bool(v, "block-incremental", &obj->block_incremental, &err);
8363 if (err) {
8364 goto out;
8365 }
8366 }
8367
8368out:
8369 error_propagate(errp, err);
8370}
8371
8372void visit_type_MigrateSetParameters(Visitor *v, const char *name, MigrateSetParameters **obj, Error **errp)
8373{
8374 Error *err = NULL;
8375
8376 visit_start_struct(v, name, (void **)obj, sizeof(MigrateSetParameters), &err);
8377 if (err) {
8378 goto out;
8379 }
8380 if (!*obj) {
8381 goto out_obj;
8382 }
8383 visit_type_MigrateSetParameters_members(v, *obj, &err);
8384 if (err) {
8385 goto out_obj;
8386 }
8387 visit_check_struct(v, &err);
8388out_obj:
8389 visit_end_struct(v, (void **)obj);
8390 if (err && visit_is_input(v)) {
8391 qapi_free_MigrateSetParameters(*obj);
8392 *obj = NULL;
8393 }
8394out:
8395 error_propagate(errp, err);
8396}
8397
8398void visit_type_MigrationCapability(Visitor *v, const char *name, MigrationCapability *obj, Error **errp)
8399{
8400 int value = *obj;
8401 visit_type_enum(v, name, &value, MigrationCapability_lookup, errp);
8402 *obj = value;
8403}
8404
8405void visit_type_MigrationCapabilityStatus_members(Visitor *v, MigrationCapabilityStatus *obj, Error **errp)
8406{
8407 Error *err = NULL;
8408
8409 visit_type_MigrationCapability(v, "capability", &obj->capability, &err);
8410 if (err) {
8411 goto out;
8412 }
8413 visit_type_bool(v, "state", &obj->state, &err);
8414 if (err) {
8415 goto out;
8416 }
8417
8418out:
8419 error_propagate(errp, err);
8420}
8421
8422void visit_type_MigrationCapabilityStatus(Visitor *v, const char *name, MigrationCapabilityStatus **obj, Error **errp)
8423{
8424 Error *err = NULL;
8425
8426 visit_start_struct(v, name, (void **)obj, sizeof(MigrationCapabilityStatus), &err);
8427 if (err) {
8428 goto out;
8429 }
8430 if (!*obj) {
8431 goto out_obj;
8432 }
8433 visit_type_MigrationCapabilityStatus_members(v, *obj, &err);
8434 if (err) {
8435 goto out_obj;
8436 }
8437 visit_check_struct(v, &err);
8438out_obj:
8439 visit_end_struct(v, (void **)obj);
8440 if (err && visit_is_input(v)) {
8441 qapi_free_MigrationCapabilityStatus(*obj);
8442 *obj = NULL;
8443 }
8444out:
8445 error_propagate(errp, err);
8446}
8447
8448void visit_type_MigrationCapabilityStatusList(Visitor *v, const char *name, MigrationCapabilityStatusList **obj, Error **errp)
8449{
8450 Error *err = NULL;
8451 MigrationCapabilityStatusList *tail;
8452 size_t size = sizeof(**obj);
8453
8454 visit_start_list(v, name, (GenericList **)obj, size, &err);
8455 if (err) {
8456 goto out;
8457 }
8458
8459 for (tail = *obj; tail;
8460 tail = (MigrationCapabilityStatusList *)visit_next_list(v, (GenericList *)tail, size)) {
8461 visit_type_MigrationCapabilityStatus(v, NULL, &tail->value, &err);
8462 if (err) {
8463 break;
8464 }
8465 }
8466
8467 if (!err) {
8468 visit_check_list(v, &err);
8469 }
8470 visit_end_list(v, (void **)obj);
8471 if (err && visit_is_input(v)) {
8472 qapi_free_MigrationCapabilityStatusList(*obj);
8473 *obj = NULL;
8474 }
8475out:
8476 error_propagate(errp, err);
8477}
8478
8479void visit_type_MigrationInfo_members(Visitor *v, MigrationInfo *obj, Error **errp)
8480{
8481 Error *err = NULL;
8482
8483 if (visit_optional(v, "status", &obj->has_status)) {
8484 visit_type_MigrationStatus(v, "status", &obj->status, &err);
8485 if (err) {
8486 goto out;
8487 }
8488 }
8489 if (visit_optional(v, "ram", &obj->has_ram)) {
8490 visit_type_MigrationStats(v, "ram", &obj->ram, &err);
8491 if (err) {
8492 goto out;
8493 }
8494 }
8495 if (visit_optional(v, "disk", &obj->has_disk)) {
8496 visit_type_MigrationStats(v, "disk", &obj->disk, &err);
8497 if (err) {
8498 goto out;
8499 }
8500 }
8501 if (visit_optional(v, "xbzrle-cache", &obj->has_xbzrle_cache)) {
8502 visit_type_XBZRLECacheStats(v, "xbzrle-cache", &obj->xbzrle_cache, &err);
8503 if (err) {
8504 goto out;
8505 }
8506 }
8507 if (visit_optional(v, "total-time", &obj->has_total_time)) {
8508 visit_type_int(v, "total-time", &obj->total_time, &err);
8509 if (err) {
8510 goto out;
8511 }
8512 }
8513 if (visit_optional(v, "expected-downtime", &obj->has_expected_downtime)) {
8514 visit_type_int(v, "expected-downtime", &obj->expected_downtime, &err);
8515 if (err) {
8516 goto out;
8517 }
8518 }
8519 if (visit_optional(v, "downtime", &obj->has_downtime)) {
8520 visit_type_int(v, "downtime", &obj->downtime, &err);
8521 if (err) {
8522 goto out;
8523 }
8524 }
8525 if (visit_optional(v, "setup-time", &obj->has_setup_time)) {
8526 visit_type_int(v, "setup-time", &obj->setup_time, &err);
8527 if (err) {
8528 goto out;
8529 }
8530 }
8531 if (visit_optional(v, "cpu-throttle-percentage", &obj->has_cpu_throttle_percentage)) {
8532 visit_type_int(v, "cpu-throttle-percentage", &obj->cpu_throttle_percentage, &err);
8533 if (err) {
8534 goto out;
8535 }
8536 }
8537 if (visit_optional(v, "error-desc", &obj->has_error_desc)) {
8538 visit_type_str(v, "error-desc", &obj->error_desc, &err);
8539 if (err) {
8540 goto out;
8541 }
8542 }
8543
8544out:
8545 error_propagate(errp, err);
8546}
8547
8548void visit_type_MigrationInfo(Visitor *v, const char *name, MigrationInfo **obj, Error **errp)
8549{
8550 Error *err = NULL;
8551
8552 visit_start_struct(v, name, (void **)obj, sizeof(MigrationInfo), &err);
8553 if (err) {
8554 goto out;
8555 }
8556 if (!*obj) {
8557 goto out_obj;
8558 }
8559 visit_type_MigrationInfo_members(v, *obj, &err);
8560 if (err) {
8561 goto out_obj;
8562 }
8563 visit_check_struct(v, &err);
8564out_obj:
8565 visit_end_struct(v, (void **)obj);
8566 if (err && visit_is_input(v)) {
8567 qapi_free_MigrationInfo(*obj);
8568 *obj = NULL;
8569 }
8570out:
8571 error_propagate(errp, err);
8572}
8573
8574void visit_type_MigrationParameter(Visitor *v, const char *name, MigrationParameter *obj, Error **errp)
8575{
8576 int value = *obj;
8577 visit_type_enum(v, name, &value, MigrationParameter_lookup, errp);
8578 *obj = value;
8579}
8580
8581void visit_type_MigrationParameters_members(Visitor *v, MigrationParameters *obj, Error **errp)
8582{
8583 Error *err = NULL;
8584
8585 if (visit_optional(v, "compress-level", &obj->has_compress_level)) {
8586 visit_type_int(v, "compress-level", &obj->compress_level, &err);
8587 if (err) {
8588 goto out;
8589 }
8590 }
8591 if (visit_optional(v, "compress-threads", &obj->has_compress_threads)) {
8592 visit_type_int(v, "compress-threads", &obj->compress_threads, &err);
8593 if (err) {
8594 goto out;
8595 }
8596 }
8597 if (visit_optional(v, "decompress-threads", &obj->has_decompress_threads)) {
8598 visit_type_int(v, "decompress-threads", &obj->decompress_threads, &err);
8599 if (err) {
8600 goto out;
8601 }
8602 }
8603 if (visit_optional(v, "cpu-throttle-initial", &obj->has_cpu_throttle_initial)) {
8604 visit_type_int(v, "cpu-throttle-initial", &obj->cpu_throttle_initial, &err);
8605 if (err) {
8606 goto out;
8607 }
8608 }
8609 if (visit_optional(v, "cpu-throttle-increment", &obj->has_cpu_throttle_increment)) {
8610 visit_type_int(v, "cpu-throttle-increment", &obj->cpu_throttle_increment, &err);
8611 if (err) {
8612 goto out;
8613 }
8614 }
8615 if (visit_optional(v, "tls-creds", &obj->has_tls_creds)) {
8616 visit_type_str(v, "tls-creds", &obj->tls_creds, &err);
8617 if (err) {
8618 goto out;
8619 }
8620 }
8621 if (visit_optional(v, "tls-hostname", &obj->has_tls_hostname)) {
8622 visit_type_str(v, "tls-hostname", &obj->tls_hostname, &err);
8623 if (err) {
8624 goto out;
8625 }
8626 }
8627 if (visit_optional(v, "max-bandwidth", &obj->has_max_bandwidth)) {
8628 visit_type_int(v, "max-bandwidth", &obj->max_bandwidth, &err);
8629 if (err) {
8630 goto out;
8631 }
8632 }
8633 if (visit_optional(v, "downtime-limit", &obj->has_downtime_limit)) {
8634 visit_type_int(v, "downtime-limit", &obj->downtime_limit, &err);
8635 if (err) {
8636 goto out;
8637 }
8638 }
8639 if (visit_optional(v, "x-checkpoint-delay", &obj->has_x_checkpoint_delay)) {
8640 visit_type_int(v, "x-checkpoint-delay", &obj->x_checkpoint_delay, &err);
8641 if (err) {
8642 goto out;
8643 }
8644 }
8645 if (visit_optional(v, "block-incremental", &obj->has_block_incremental)) {
8646 visit_type_bool(v, "block-incremental", &obj->block_incremental, &err);
8647 if (err) {
8648 goto out;
8649 }
8650 }
8651
8652out:
8653 error_propagate(errp, err);
8654}
8655
8656void visit_type_MigrationParameters(Visitor *v, const char *name, MigrationParameters **obj, Error **errp)
8657{
8658 Error *err = NULL;
8659
8660 visit_start_struct(v, name, (void **)obj, sizeof(MigrationParameters), &err);
8661 if (err) {
8662 goto out;
8663 }
8664 if (!*obj) {
8665 goto out_obj;
8666 }
8667 visit_type_MigrationParameters_members(v, *obj, &err);
8668 if (err) {
8669 goto out_obj;
8670 }
8671 visit_check_struct(v, &err);
8672out_obj:
8673 visit_end_struct(v, (void **)obj);
8674 if (err && visit_is_input(v)) {
8675 qapi_free_MigrationParameters(*obj);
8676 *obj = NULL;
8677 }
8678out:
8679 error_propagate(errp, err);
8680}
8681
8682void visit_type_MigrationStats_members(Visitor *v, MigrationStats *obj, Error **errp)
8683{
8684 Error *err = NULL;
8685
8686 visit_type_int(v, "transferred", &obj->transferred, &err);
8687 if (err) {
8688 goto out;
8689 }
8690 visit_type_int(v, "remaining", &obj->remaining, &err);
8691 if (err) {
8692 goto out;
8693 }
8694 visit_type_int(v, "total", &obj->total, &err);
8695 if (err) {
8696 goto out;
8697 }
8698 visit_type_int(v, "duplicate", &obj->duplicate, &err);
8699 if (err) {
8700 goto out;
8701 }
8702 visit_type_int(v, "skipped", &obj->skipped, &err);
8703 if (err) {
8704 goto out;
8705 }
8706 visit_type_int(v, "normal", &obj->normal, &err);
8707 if (err) {
8708 goto out;
8709 }
8710 visit_type_int(v, "normal-bytes", &obj->normal_bytes, &err);
8711 if (err) {
8712 goto out;
8713 }
8714 visit_type_int(v, "dirty-pages-rate", &obj->dirty_pages_rate, &err);
8715 if (err) {
8716 goto out;
8717 }
8718 visit_type_number(v, "mbps", &obj->mbps, &err);
8719 if (err) {
8720 goto out;
8721 }
8722 visit_type_int(v, "dirty-sync-count", &obj->dirty_sync_count, &err);
8723 if (err) {
8724 goto out;
8725 }
8726 visit_type_int(v, "postcopy-requests", &obj->postcopy_requests, &err);
8727 if (err) {
8728 goto out;
8729 }
8730 visit_type_int(v, "page-size", &obj->page_size, &err);
8731 if (err) {
8732 goto out;
8733 }
8734
8735out:
8736 error_propagate(errp, err);
8737}
8738
8739void visit_type_MigrationStats(Visitor *v, const char *name, MigrationStats **obj, Error **errp)
8740{
8741 Error *err = NULL;
8742
8743 visit_start_struct(v, name, (void **)obj, sizeof(MigrationStats), &err);
8744 if (err) {
8745 goto out;
8746 }
8747 if (!*obj) {
8748 goto out_obj;
8749 }
8750 visit_type_MigrationStats_members(v, *obj, &err);
8751 if (err) {
8752 goto out_obj;
8753 }
8754 visit_check_struct(v, &err);
8755out_obj:
8756 visit_end_struct(v, (void **)obj);
8757 if (err && visit_is_input(v)) {
8758 qapi_free_MigrationStats(*obj);
8759 *obj = NULL;
8760 }
8761out:
8762 error_propagate(errp, err);
8763}
8764
8765void visit_type_MigrationStatus(Visitor *v, const char *name, MigrationStatus *obj, Error **errp)
8766{
8767 int value = *obj;
8768 visit_type_enum(v, name, &value, MigrationStatus_lookup, errp);
8769 *obj = value;
8770}
8771
8772void visit_type_MirrorSyncMode(Visitor *v, const char *name, MirrorSyncMode *obj, Error **errp)
8773{
8774 int value = *obj;
8775 visit_type_enum(v, name, &value, MirrorSyncMode_lookup, errp);
8776 *obj = value;
8777}
8778
8779void visit_type_MouseInfo_members(Visitor *v, MouseInfo *obj, Error **errp)
8780{
8781 Error *err = NULL;
8782
8783 visit_type_str(v, "name", &obj->name, &err);
8784 if (err) {
8785 goto out;
8786 }
8787 visit_type_int(v, "index", &obj->index, &err);
8788 if (err) {
8789 goto out;
8790 }
8791 visit_type_bool(v, "current", &obj->current, &err);
8792 if (err) {
8793 goto out;
8794 }
8795 visit_type_bool(v, "absolute", &obj->absolute, &err);
8796 if (err) {
8797 goto out;
8798 }
8799
8800out:
8801 error_propagate(errp, err);
8802}
8803
8804void visit_type_MouseInfo(Visitor *v, const char *name, MouseInfo **obj, Error **errp)
8805{
8806 Error *err = NULL;
8807
8808 visit_start_struct(v, name, (void **)obj, sizeof(MouseInfo), &err);
8809 if (err) {
8810 goto out;
8811 }
8812 if (!*obj) {
8813 goto out_obj;
8814 }
8815 visit_type_MouseInfo_members(v, *obj, &err);
8816 if (err) {
8817 goto out_obj;
8818 }
8819 visit_check_struct(v, &err);
8820out_obj:
8821 visit_end_struct(v, (void **)obj);
8822 if (err && visit_is_input(v)) {
8823 qapi_free_MouseInfo(*obj);
8824 *obj = NULL;
8825 }
8826out:
8827 error_propagate(errp, err);
8828}
8829
8830void visit_type_MouseInfoList(Visitor *v, const char *name, MouseInfoList **obj, Error **errp)
8831{
8832 Error *err = NULL;
8833 MouseInfoList *tail;
8834 size_t size = sizeof(**obj);
8835
8836 visit_start_list(v, name, (GenericList **)obj, size, &err);
8837 if (err) {
8838 goto out;
8839 }
8840
8841 for (tail = *obj; tail;
8842 tail = (MouseInfoList *)visit_next_list(v, (GenericList *)tail, size)) {
8843 visit_type_MouseInfo(v, NULL, &tail->value, &err);
8844 if (err) {
8845 break;
8846 }
8847 }
8848
8849 if (!err) {
8850 visit_check_list(v, &err);
8851 }
8852 visit_end_list(v, (void **)obj);
8853 if (err && visit_is_input(v)) {
8854 qapi_free_MouseInfoList(*obj);
8855 *obj = NULL;
8856 }
8857out:
8858 error_propagate(errp, err);
8859}
8860
8861void visit_type_NFSServer_members(Visitor *v, NFSServer *obj, Error **errp)
8862{
8863 Error *err = NULL;
8864
8865 visit_type_NFSTransport(v, "type", &obj->type, &err);
8866 if (err) {
8867 goto out;
8868 }
8869 visit_type_str(v, "host", &obj->host, &err);
8870 if (err) {
8871 goto out;
8872 }
8873
8874out:
8875 error_propagate(errp, err);
8876}
8877
8878void visit_type_NFSServer(Visitor *v, const char *name, NFSServer **obj, Error **errp)
8879{
8880 Error *err = NULL;
8881
8882 visit_start_struct(v, name, (void **)obj, sizeof(NFSServer), &err);
8883 if (err) {
8884 goto out;
8885 }
8886 if (!*obj) {
8887 goto out_obj;
8888 }
8889 visit_type_NFSServer_members(v, *obj, &err);
8890 if (err) {
8891 goto out_obj;
8892 }
8893 visit_check_struct(v, &err);
8894out_obj:
8895 visit_end_struct(v, (void **)obj);
8896 if (err && visit_is_input(v)) {
8897 qapi_free_NFSServer(*obj);
8898 *obj = NULL;
8899 }
8900out:
8901 error_propagate(errp, err);
8902}
8903
8904void visit_type_NFSTransport(Visitor *v, const char *name, NFSTransport *obj, Error **errp)
8905{
8906 int value = *obj;
8907 visit_type_enum(v, name, &value, NFSTransport_lookup, errp);
8908 *obj = value;
8909}
8910
8911void visit_type_NameInfo_members(Visitor *v, NameInfo *obj, Error **errp)
8912{
8913 Error *err = NULL;
8914
8915 if (visit_optional(v, "name", &obj->has_name)) {
8916 visit_type_str(v, "name", &obj->name, &err);
8917 if (err) {
8918 goto out;
8919 }
8920 }
8921
8922out:
8923 error_propagate(errp, err);
8924}
8925
8926void visit_type_NameInfo(Visitor *v, const char *name, NameInfo **obj, Error **errp)
8927{
8928 Error *err = NULL;
8929
8930 visit_start_struct(v, name, (void **)obj, sizeof(NameInfo), &err);
8931 if (err) {
8932 goto out;
8933 }
8934 if (!*obj) {
8935 goto out_obj;
8936 }
8937 visit_type_NameInfo_members(v, *obj, &err);
8938 if (err) {
8939 goto out_obj;
8940 }
8941 visit_check_struct(v, &err);
8942out_obj:
8943 visit_end_struct(v, (void **)obj);
8944 if (err && visit_is_input(v)) {
8945 qapi_free_NameInfo(*obj);
8946 *obj = NULL;
8947 }
8948out:
8949 error_propagate(errp, err);
8950}
8951
8952void visit_type_NetClientDriver(Visitor *v, const char *name, NetClientDriver *obj, Error **errp)
8953{
8954 int value = *obj;
8955 visit_type_enum(v, name, &value, NetClientDriver_lookup, errp);
8956 *obj = value;
8957}
8958
8959void visit_type_NetFilterDirection(Visitor *v, const char *name, NetFilterDirection *obj, Error **errp)
8960{
8961 int value = *obj;
8962 visit_type_enum(v, name, &value, NetFilterDirection_lookup, errp);
8963 *obj = value;
8964}
8965
8966void visit_type_NetLegacy_members(Visitor *v, NetLegacy *obj, Error **errp)
8967{
8968 Error *err = NULL;
8969
8970 if (visit_optional(v, "vlan", &obj->has_vlan)) {
8971 visit_type_int32(v, "vlan", &obj->vlan, &err);
8972 if (err) {
8973 goto out;
8974 }
8975 }
8976 if (visit_optional(v, "id", &obj->has_id)) {
8977 visit_type_str(v, "id", &obj->id, &err);
8978 if (err) {
8979 goto out;
8980 }
8981 }
8982 if (visit_optional(v, "name", &obj->has_name)) {
8983 visit_type_str(v, "name", &obj->name, &err);
8984 if (err) {
8985 goto out;
8986 }
8987 }
8988 visit_type_NetLegacyOptions(v, "opts", &obj->opts, &err);
8989 if (err) {
8990 goto out;
8991 }
8992
8993out:
8994 error_propagate(errp, err);
8995}
8996
8997void visit_type_NetLegacy(Visitor *v, const char *name, NetLegacy **obj, Error **errp)
8998{
8999 Error *err = NULL;
9000
9001 visit_start_struct(v, name, (void **)obj, sizeof(NetLegacy), &err);
9002 if (err) {
9003 goto out;
9004 }
9005 if (!*obj) {
9006 goto out_obj;
9007 }
9008 visit_type_NetLegacy_members(v, *obj, &err);
9009 if (err) {
9010 goto out_obj;
9011 }
9012 visit_check_struct(v, &err);
9013out_obj:
9014 visit_end_struct(v, (void **)obj);
9015 if (err && visit_is_input(v)) {
9016 qapi_free_NetLegacy(*obj);
9017 *obj = NULL;
9018 }
9019out:
9020 error_propagate(errp, err);
9021}
9022
9023void visit_type_NetLegacyNicOptions_members(Visitor *v, NetLegacyNicOptions *obj, Error **errp)
9024{
9025 Error *err = NULL;
9026
9027 if (visit_optional(v, "netdev", &obj->has_netdev)) {
9028 visit_type_str(v, "netdev", &obj->netdev, &err);
9029 if (err) {
9030 goto out;
9031 }
9032 }
9033 if (visit_optional(v, "macaddr", &obj->has_macaddr)) {
9034 visit_type_str(v, "macaddr", &obj->macaddr, &err);
9035 if (err) {
9036 goto out;
9037 }
9038 }
9039 if (visit_optional(v, "model", &obj->has_model)) {
9040 visit_type_str(v, "model", &obj->model, &err);
9041 if (err) {
9042 goto out;
9043 }
9044 }
9045 if (visit_optional(v, "addr", &obj->has_addr)) {
9046 visit_type_str(v, "addr", &obj->addr, &err);
9047 if (err) {
9048 goto out;
9049 }
9050 }
9051 if (visit_optional(v, "vectors", &obj->has_vectors)) {
9052 visit_type_uint32(v, "vectors", &obj->vectors, &err);
9053 if (err) {
9054 goto out;
9055 }
9056 }
9057
9058out:
9059 error_propagate(errp, err);
9060}
9061
9062void visit_type_NetLegacyNicOptions(Visitor *v, const char *name, NetLegacyNicOptions **obj, Error **errp)
9063{
9064 Error *err = NULL;
9065
9066 visit_start_struct(v, name, (void **)obj, sizeof(NetLegacyNicOptions), &err);
9067 if (err) {
9068 goto out;
9069 }
9070 if (!*obj) {
9071 goto out_obj;
9072 }
9073 visit_type_NetLegacyNicOptions_members(v, *obj, &err);
9074 if (err) {
9075 goto out_obj;
9076 }
9077 visit_check_struct(v, &err);
9078out_obj:
9079 visit_end_struct(v, (void **)obj);
9080 if (err && visit_is_input(v)) {
9081 qapi_free_NetLegacyNicOptions(*obj);
9082 *obj = NULL;
9083 }
9084out:
9085 error_propagate(errp, err);
9086}
9087
9088void visit_type_NetLegacyOptions_members(Visitor *v, NetLegacyOptions *obj, Error **errp)
9089{
9090 Error *err = NULL;
9091
9092 visit_type_q_obj_NetLegacyOptions_base_members(v, (q_obj_NetLegacyOptions_base *)obj, &err);
9093 if (err) {
9094 goto out;
9095 }
9096 switch (obj->type) {
9097 case NET_LEGACY_OPTIONS_TYPE_NONE:
9098 visit_type_NetdevNoneOptions_members(v, &obj->u.none, &err);
9099 break;
9100 case NET_LEGACY_OPTIONS_TYPE_NIC:
9101 visit_type_NetLegacyNicOptions_members(v, &obj->u.nic, &err);
9102 break;
9103 case NET_LEGACY_OPTIONS_TYPE_USER:
9104 visit_type_NetdevUserOptions_members(v, &obj->u.user, &err);
9105 break;
9106 case NET_LEGACY_OPTIONS_TYPE_TAP:
9107 visit_type_NetdevTapOptions_members(v, &obj->u.tap, &err);
9108 break;
9109 case NET_LEGACY_OPTIONS_TYPE_L2TPV3:
9110 visit_type_NetdevL2TPv3Options_members(v, &obj->u.l2tpv3, &err);
9111 break;
9112 case NET_LEGACY_OPTIONS_TYPE_SOCKET:
9113 visit_type_NetdevSocketOptions_members(v, &obj->u.socket, &err);
9114 break;
9115 case NET_LEGACY_OPTIONS_TYPE_VDE:
9116 visit_type_NetdevVdeOptions_members(v, &obj->u.vde, &err);
9117 break;
9118 case NET_LEGACY_OPTIONS_TYPE_DUMP:
9119 visit_type_NetdevDumpOptions_members(v, &obj->u.dump, &err);
9120 break;
9121 case NET_LEGACY_OPTIONS_TYPE_BRIDGE:
9122 visit_type_NetdevBridgeOptions_members(v, &obj->u.bridge, &err);
9123 break;
9124 case NET_LEGACY_OPTIONS_TYPE_NETMAP:
9125 visit_type_NetdevNetmapOptions_members(v, &obj->u.netmap, &err);
9126 break;
9127 case NET_LEGACY_OPTIONS_TYPE_VHOST_USER:
9128 visit_type_NetdevVhostUserOptions_members(v, &obj->u.vhost_user, &err);
9129 break;
9130 default:
9131 abort();
9132 }
9133
9134out:
9135 error_propagate(errp, err);
9136}
9137
9138void visit_type_NetLegacyOptions(Visitor *v, const char *name, NetLegacyOptions **obj, Error **errp)
9139{
9140 Error *err = NULL;
9141
9142 visit_start_struct(v, name, (void **)obj, sizeof(NetLegacyOptions), &err);
9143 if (err) {
9144 goto out;
9145 }
9146 if (!*obj) {
9147 goto out_obj;
9148 }
9149 visit_type_NetLegacyOptions_members(v, *obj, &err);
9150 if (err) {
9151 goto out_obj;
9152 }
9153 visit_check_struct(v, &err);
9154out_obj:
9155 visit_end_struct(v, (void **)obj);
9156 if (err && visit_is_input(v)) {
9157 qapi_free_NetLegacyOptions(*obj);
9158 *obj = NULL;
9159 }
9160out:
9161 error_propagate(errp, err);
9162}
9163
9164void visit_type_NetLegacyOptionsType(Visitor *v, const char *name, NetLegacyOptionsType *obj, Error **errp)
9165{
9166 int value = *obj;
9167 visit_type_enum(v, name, &value, NetLegacyOptionsType_lookup, errp);
9168 *obj = value;
9169}
9170
9171void visit_type_Netdev_members(Visitor *v, Netdev *obj, Error **errp)
9172{
9173 Error *err = NULL;
9174
9175 visit_type_q_obj_Netdev_base_members(v, (q_obj_Netdev_base *)obj, &err);
9176 if (err) {
9177 goto out;
9178 }
9179 switch (obj->type) {
9180 case NET_CLIENT_DRIVER_NONE:
9181 visit_type_NetdevNoneOptions_members(v, &obj->u.none, &err);
9182 break;
9183 case NET_CLIENT_DRIVER_NIC:
9184 visit_type_NetLegacyNicOptions_members(v, &obj->u.nic, &err);
9185 break;
9186 case NET_CLIENT_DRIVER_USER:
9187 visit_type_NetdevUserOptions_members(v, &obj->u.user, &err);
9188 break;
9189 case NET_CLIENT_DRIVER_TAP:
9190 visit_type_NetdevTapOptions_members(v, &obj->u.tap, &err);
9191 break;
9192 case NET_CLIENT_DRIVER_L2TPV3:
9193 visit_type_NetdevL2TPv3Options_members(v, &obj->u.l2tpv3, &err);
9194 break;
9195 case NET_CLIENT_DRIVER_SOCKET:
9196 visit_type_NetdevSocketOptions_members(v, &obj->u.socket, &err);
9197 break;
9198 case NET_CLIENT_DRIVER_VDE:
9199 visit_type_NetdevVdeOptions_members(v, &obj->u.vde, &err);
9200 break;
9201 case NET_CLIENT_DRIVER_DUMP:
9202 visit_type_NetdevDumpOptions_members(v, &obj->u.dump, &err);
9203 break;
9204 case NET_CLIENT_DRIVER_BRIDGE:
9205 visit_type_NetdevBridgeOptions_members(v, &obj->u.bridge, &err);
9206 break;
9207 case NET_CLIENT_DRIVER_HUBPORT:
9208 visit_type_NetdevHubPortOptions_members(v, &obj->u.hubport, &err);
9209 break;
9210 case NET_CLIENT_DRIVER_NETMAP:
9211 visit_type_NetdevNetmapOptions_members(v, &obj->u.netmap, &err);
9212 break;
9213 case NET_CLIENT_DRIVER_VHOST_USER:
9214 visit_type_NetdevVhostUserOptions_members(v, &obj->u.vhost_user, &err);
9215 break;
9216 default:
9217 abort();
9218 }
9219
9220out:
9221 error_propagate(errp, err);
9222}
9223
9224void visit_type_Netdev(Visitor *v, const char *name, Netdev **obj, Error **errp)
9225{
9226 Error *err = NULL;
9227
9228 visit_start_struct(v, name, (void **)obj, sizeof(Netdev), &err);
9229 if (err) {
9230 goto out;
9231 }
9232 if (!*obj) {
9233 goto out_obj;
9234 }
9235 visit_type_Netdev_members(v, *obj, &err);
9236 if (err) {
9237 goto out_obj;
9238 }
9239 visit_check_struct(v, &err);
9240out_obj:
9241 visit_end_struct(v, (void **)obj);
9242 if (err && visit_is_input(v)) {
9243 qapi_free_Netdev(*obj);
9244 *obj = NULL;
9245 }
9246out:
9247 error_propagate(errp, err);
9248}
9249
9250void visit_type_NetdevBridgeOptions_members(Visitor *v, NetdevBridgeOptions *obj, Error **errp)
9251{
9252 Error *err = NULL;
9253
9254 if (visit_optional(v, "br", &obj->has_br)) {
9255 visit_type_str(v, "br", &obj->br, &err);
9256 if (err) {
9257 goto out;
9258 }
9259 }
9260 if (visit_optional(v, "helper", &obj->has_helper)) {
9261 visit_type_str(v, "helper", &obj->helper, &err);
9262 if (err) {
9263 goto out;
9264 }
9265 }
9266
9267out:
9268 error_propagate(errp, err);
9269}
9270
9271void visit_type_NetdevBridgeOptions(Visitor *v, const char *name, NetdevBridgeOptions **obj, Error **errp)
9272{
9273 Error *err = NULL;
9274
9275 visit_start_struct(v, name, (void **)obj, sizeof(NetdevBridgeOptions), &err);
9276 if (err) {
9277 goto out;
9278 }
9279 if (!*obj) {
9280 goto out_obj;
9281 }
9282 visit_type_NetdevBridgeOptions_members(v, *obj, &err);
9283 if (err) {
9284 goto out_obj;
9285 }
9286 visit_check_struct(v, &err);
9287out_obj:
9288 visit_end_struct(v, (void **)obj);
9289 if (err && visit_is_input(v)) {
9290 qapi_free_NetdevBridgeOptions(*obj);
9291 *obj = NULL;
9292 }
9293out:
9294 error_propagate(errp, err);
9295}
9296
9297void visit_type_NetdevDumpOptions_members(Visitor *v, NetdevDumpOptions *obj, Error **errp)
9298{
9299 Error *err = NULL;
9300
9301 if (visit_optional(v, "len", &obj->has_len)) {
9302 visit_type_size(v, "len", &obj->len, &err);
9303 if (err) {
9304 goto out;
9305 }
9306 }
9307 if (visit_optional(v, "file", &obj->has_file)) {
9308 visit_type_str(v, "file", &obj->file, &err);
9309 if (err) {
9310 goto out;
9311 }
9312 }
9313
9314out:
9315 error_propagate(errp, err);
9316}
9317
9318void visit_type_NetdevDumpOptions(Visitor *v, const char *name, NetdevDumpOptions **obj, Error **errp)
9319{
9320 Error *err = NULL;
9321
9322 visit_start_struct(v, name, (void **)obj, sizeof(NetdevDumpOptions), &err);
9323 if (err) {
9324 goto out;
9325 }
9326 if (!*obj) {
9327 goto out_obj;
9328 }
9329 visit_type_NetdevDumpOptions_members(v, *obj, &err);
9330 if (err) {
9331 goto out_obj;
9332 }
9333 visit_check_struct(v, &err);
9334out_obj:
9335 visit_end_struct(v, (void **)obj);
9336 if (err && visit_is_input(v)) {
9337 qapi_free_NetdevDumpOptions(*obj);
9338 *obj = NULL;
9339 }
9340out:
9341 error_propagate(errp, err);
9342}
9343
9344void visit_type_NetdevHubPortOptions_members(Visitor *v, NetdevHubPortOptions *obj, Error **errp)
9345{
9346 Error *err = NULL;
9347
9348 visit_type_int32(v, "hubid", &obj->hubid, &err);
9349 if (err) {
9350 goto out;
9351 }
9352
9353out:
9354 error_propagate(errp, err);
9355}
9356
9357void visit_type_NetdevHubPortOptions(Visitor *v, const char *name, NetdevHubPortOptions **obj, Error **errp)
9358{
9359 Error *err = NULL;
9360
9361 visit_start_struct(v, name, (void **)obj, sizeof(NetdevHubPortOptions), &err);
9362 if (err) {
9363 goto out;
9364 }
9365 if (!*obj) {
9366 goto out_obj;
9367 }
9368 visit_type_NetdevHubPortOptions_members(v, *obj, &err);
9369 if (err) {
9370 goto out_obj;
9371 }
9372 visit_check_struct(v, &err);
9373out_obj:
9374 visit_end_struct(v, (void **)obj);
9375 if (err && visit_is_input(v)) {
9376 qapi_free_NetdevHubPortOptions(*obj);
9377 *obj = NULL;
9378 }
9379out:
9380 error_propagate(errp, err);
9381}
9382
9383void visit_type_NetdevL2TPv3Options_members(Visitor *v, NetdevL2TPv3Options *obj, Error **errp)
9384{
9385 Error *err = NULL;
9386
9387 visit_type_str(v, "src", &obj->src, &err);
9388 if (err) {
9389 goto out;
9390 }
9391 visit_type_str(v, "dst", &obj->dst, &err);
9392 if (err) {
9393 goto out;
9394 }
9395 if (visit_optional(v, "srcport", &obj->has_srcport)) {
9396 visit_type_str(v, "srcport", &obj->srcport, &err);
9397 if (err) {
9398 goto out;
9399 }
9400 }
9401 if (visit_optional(v, "dstport", &obj->has_dstport)) {
9402 visit_type_str(v, "dstport", &obj->dstport, &err);
9403 if (err) {
9404 goto out;
9405 }
9406 }
9407 if (visit_optional(v, "ipv6", &obj->has_ipv6)) {
9408 visit_type_bool(v, "ipv6", &obj->ipv6, &err);
9409 if (err) {
9410 goto out;
9411 }
9412 }
9413 if (visit_optional(v, "udp", &obj->has_udp)) {
9414 visit_type_bool(v, "udp", &obj->udp, &err);
9415 if (err) {
9416 goto out;
9417 }
9418 }
9419 if (visit_optional(v, "cookie64", &obj->has_cookie64)) {
9420 visit_type_bool(v, "cookie64", &obj->cookie64, &err);
9421 if (err) {
9422 goto out;
9423 }
9424 }
9425 if (visit_optional(v, "counter", &obj->has_counter)) {
9426 visit_type_bool(v, "counter", &obj->counter, &err);
9427 if (err) {
9428 goto out;
9429 }
9430 }
9431 if (visit_optional(v, "pincounter", &obj->has_pincounter)) {
9432 visit_type_bool(v, "pincounter", &obj->pincounter, &err);
9433 if (err) {
9434 goto out;
9435 }
9436 }
9437 if (visit_optional(v, "txcookie", &obj->has_txcookie)) {
9438 visit_type_uint64(v, "txcookie", &obj->txcookie, &err);
9439 if (err) {
9440 goto out;
9441 }
9442 }
9443 if (visit_optional(v, "rxcookie", &obj->has_rxcookie)) {
9444 visit_type_uint64(v, "rxcookie", &obj->rxcookie, &err);
9445 if (err) {
9446 goto out;
9447 }
9448 }
9449 visit_type_uint32(v, "txsession", &obj->txsession, &err);
9450 if (err) {
9451 goto out;
9452 }
9453 if (visit_optional(v, "rxsession", &obj->has_rxsession)) {
9454 visit_type_uint32(v, "rxsession", &obj->rxsession, &err);
9455 if (err) {
9456 goto out;
9457 }
9458 }
9459 if (visit_optional(v, "offset", &obj->has_offset)) {
9460 visit_type_uint32(v, "offset", &obj->offset, &err);
9461 if (err) {
9462 goto out;
9463 }
9464 }
9465
9466out:
9467 error_propagate(errp, err);
9468}
9469
9470void visit_type_NetdevL2TPv3Options(Visitor *v, const char *name, NetdevL2TPv3Options **obj, Error **errp)
9471{
9472 Error *err = NULL;
9473
9474 visit_start_struct(v, name, (void **)obj, sizeof(NetdevL2TPv3Options), &err);
9475 if (err) {
9476 goto out;
9477 }
9478 if (!*obj) {
9479 goto out_obj;
9480 }
9481 visit_type_NetdevL2TPv3Options_members(v, *obj, &err);
9482 if (err) {
9483 goto out_obj;
9484 }
9485 visit_check_struct(v, &err);
9486out_obj:
9487 visit_end_struct(v, (void **)obj);
9488 if (err && visit_is_input(v)) {
9489 qapi_free_NetdevL2TPv3Options(*obj);
9490 *obj = NULL;
9491 }
9492out:
9493 error_propagate(errp, err);
9494}
9495
9496void visit_type_NetdevNetmapOptions_members(Visitor *v, NetdevNetmapOptions *obj, Error **errp)
9497{
9498 Error *err = NULL;
9499
9500 visit_type_str(v, "ifname", &obj->ifname, &err);
9501 if (err) {
9502 goto out;
9503 }
9504 if (visit_optional(v, "devname", &obj->has_devname)) {
9505 visit_type_str(v, "devname", &obj->devname, &err);
9506 if (err) {
9507 goto out;
9508 }
9509 }
9510
9511out:
9512 error_propagate(errp, err);
9513}
9514
9515void visit_type_NetdevNetmapOptions(Visitor *v, const char *name, NetdevNetmapOptions **obj, Error **errp)
9516{
9517 Error *err = NULL;
9518
9519 visit_start_struct(v, name, (void **)obj, sizeof(NetdevNetmapOptions), &err);
9520 if (err) {
9521 goto out;
9522 }
9523 if (!*obj) {
9524 goto out_obj;
9525 }
9526 visit_type_NetdevNetmapOptions_members(v, *obj, &err);
9527 if (err) {
9528 goto out_obj;
9529 }
9530 visit_check_struct(v, &err);
9531out_obj:
9532 visit_end_struct(v, (void **)obj);
9533 if (err && visit_is_input(v)) {
9534 qapi_free_NetdevNetmapOptions(*obj);
9535 *obj = NULL;
9536 }
9537out:
9538 error_propagate(errp, err);
9539}
9540
9541void visit_type_NetdevNoneOptions_members(Visitor *v, NetdevNoneOptions *obj, Error **errp)
9542{
9543 Error *err = NULL;
9544
9545 error_propagate(errp, err);
9546}
9547
9548void visit_type_NetdevNoneOptions(Visitor *v, const char *name, NetdevNoneOptions **obj, Error **errp)
9549{
9550 Error *err = NULL;
9551
9552 visit_start_struct(v, name, (void **)obj, sizeof(NetdevNoneOptions), &err);
9553 if (err) {
9554 goto out;
9555 }
9556 if (!*obj) {
9557 goto out_obj;
9558 }
9559 visit_type_NetdevNoneOptions_members(v, *obj, &err);
9560 if (err) {
9561 goto out_obj;
9562 }
9563 visit_check_struct(v, &err);
9564out_obj:
9565 visit_end_struct(v, (void **)obj);
9566 if (err && visit_is_input(v)) {
9567 qapi_free_NetdevNoneOptions(*obj);
9568 *obj = NULL;
9569 }
9570out:
9571 error_propagate(errp, err);
9572}
9573
9574void visit_type_NetdevSocketOptions_members(Visitor *v, NetdevSocketOptions *obj, Error **errp)
9575{
9576 Error *err = NULL;
9577
9578 if (visit_optional(v, "fd", &obj->has_fd)) {
9579 visit_type_str(v, "fd", &obj->fd, &err);
9580 if (err) {
9581 goto out;
9582 }
9583 }
9584 if (visit_optional(v, "listen", &obj->has_listen)) {
9585 visit_type_str(v, "listen", &obj->listen, &err);
9586 if (err) {
9587 goto out;
9588 }
9589 }
9590 if (visit_optional(v, "connect", &obj->has_connect)) {
9591 visit_type_str(v, "connect", &obj->connect, &err);
9592 if (err) {
9593 goto out;
9594 }
9595 }
9596 if (visit_optional(v, "mcast", &obj->has_mcast)) {
9597 visit_type_str(v, "mcast", &obj->mcast, &err);
9598 if (err) {
9599 goto out;
9600 }
9601 }
9602 if (visit_optional(v, "localaddr", &obj->has_localaddr)) {
9603 visit_type_str(v, "localaddr", &obj->localaddr, &err);
9604 if (err) {
9605 goto out;
9606 }
9607 }
9608 if (visit_optional(v, "udp", &obj->has_udp)) {
9609 visit_type_str(v, "udp", &obj->udp, &err);
9610 if (err) {
9611 goto out;
9612 }
9613 }
9614
9615out:
9616 error_propagate(errp, err);
9617}
9618
9619void visit_type_NetdevSocketOptions(Visitor *v, const char *name, NetdevSocketOptions **obj, Error **errp)
9620{
9621 Error *err = NULL;
9622
9623 visit_start_struct(v, name, (void **)obj, sizeof(NetdevSocketOptions), &err);
9624 if (err) {
9625 goto out;
9626 }
9627 if (!*obj) {
9628 goto out_obj;
9629 }
9630 visit_type_NetdevSocketOptions_members(v, *obj, &err);
9631 if (err) {
9632 goto out_obj;
9633 }
9634 visit_check_struct(v, &err);
9635out_obj:
9636 visit_end_struct(v, (void **)obj);
9637 if (err && visit_is_input(v)) {
9638 qapi_free_NetdevSocketOptions(*obj);
9639 *obj = NULL;
9640 }
9641out:
9642 error_propagate(errp, err);
9643}
9644
9645void visit_type_NetdevTapOptions_members(Visitor *v, NetdevTapOptions *obj, Error **errp)
9646{
9647 Error *err = NULL;
9648
9649 if (visit_optional(v, "ifname", &obj->has_ifname)) {
9650 visit_type_str(v, "ifname", &obj->ifname, &err);
9651 if (err) {
9652 goto out;
9653 }
9654 }
9655 if (visit_optional(v, "fd", &obj->has_fd)) {
9656 visit_type_str(v, "fd", &obj->fd, &err);
9657 if (err) {
9658 goto out;
9659 }
9660 }
9661 if (visit_optional(v, "fds", &obj->has_fds)) {
9662 visit_type_str(v, "fds", &obj->fds, &err);
9663 if (err) {
9664 goto out;
9665 }
9666 }
9667 if (visit_optional(v, "script", &obj->has_script)) {
9668 visit_type_str(v, "script", &obj->script, &err);
9669 if (err) {
9670 goto out;
9671 }
9672 }
9673 if (visit_optional(v, "downscript", &obj->has_downscript)) {
9674 visit_type_str(v, "downscript", &obj->downscript, &err);
9675 if (err) {
9676 goto out;
9677 }
9678 }
9679 if (visit_optional(v, "br", &obj->has_br)) {
9680 visit_type_str(v, "br", &obj->br, &err);
9681 if (err) {
9682 goto out;
9683 }
9684 }
9685 if (visit_optional(v, "helper", &obj->has_helper)) {
9686 visit_type_str(v, "helper", &obj->helper, &err);
9687 if (err) {
9688 goto out;
9689 }
9690 }
9691 if (visit_optional(v, "sndbuf", &obj->has_sndbuf)) {
9692 visit_type_size(v, "sndbuf", &obj->sndbuf, &err);
9693 if (err) {
9694 goto out;
9695 }
9696 }
9697 if (visit_optional(v, "vnet_hdr", &obj->has_vnet_hdr)) {
9698 visit_type_bool(v, "vnet_hdr", &obj->vnet_hdr, &err);
9699 if (err) {
9700 goto out;
9701 }
9702 }
9703 if (visit_optional(v, "vhost", &obj->has_vhost)) {
9704 visit_type_bool(v, "vhost", &obj->vhost, &err);
9705 if (err) {
9706 goto out;
9707 }
9708 }
9709 if (visit_optional(v, "vhostfd", &obj->has_vhostfd)) {
9710 visit_type_str(v, "vhostfd", &obj->vhostfd, &err);
9711 if (err) {
9712 goto out;
9713 }
9714 }
9715 if (visit_optional(v, "vhostfds", &obj->has_vhostfds)) {
9716 visit_type_str(v, "vhostfds", &obj->vhostfds, &err);
9717 if (err) {
9718 goto out;
9719 }
9720 }
9721 if (visit_optional(v, "vhostforce", &obj->has_vhostforce)) {
9722 visit_type_bool(v, "vhostforce", &obj->vhostforce, &err);
9723 if (err) {
9724 goto out;
9725 }
9726 }
9727 if (visit_optional(v, "queues", &obj->has_queues)) {
9728 visit_type_uint32(v, "queues", &obj->queues, &err);
9729 if (err) {
9730 goto out;
9731 }
9732 }
9733 if (visit_optional(v, "poll-us", &obj->has_poll_us)) {
9734 visit_type_uint32(v, "poll-us", &obj->poll_us, &err);
9735 if (err) {
9736 goto out;
9737 }
9738 }
9739
9740out:
9741 error_propagate(errp, err);
9742}
9743
9744void visit_type_NetdevTapOptions(Visitor *v, const char *name, NetdevTapOptions **obj, Error **errp)
9745{
9746 Error *err = NULL;
9747
9748 visit_start_struct(v, name, (void **)obj, sizeof(NetdevTapOptions), &err);
9749 if (err) {
9750 goto out;
9751 }
9752 if (!*obj) {
9753 goto out_obj;
9754 }
9755 visit_type_NetdevTapOptions_members(v, *obj, &err);
9756 if (err) {
9757 goto out_obj;
9758 }
9759 visit_check_struct(v, &err);
9760out_obj:
9761 visit_end_struct(v, (void **)obj);
9762 if (err && visit_is_input(v)) {
9763 qapi_free_NetdevTapOptions(*obj);
9764 *obj = NULL;
9765 }
9766out:
9767 error_propagate(errp, err);
9768}
9769
9770void visit_type_NetdevUserOptions_members(Visitor *v, NetdevUserOptions *obj, Error **errp)
9771{
9772 Error *err = NULL;
9773
9774 if (visit_optional(v, "hostname", &obj->has_hostname)) {
9775 visit_type_str(v, "hostname", &obj->hostname, &err);
9776 if (err) {
9777 goto out;
9778 }
9779 }
9780 if (visit_optional(v, "restrict", &obj->has_q_restrict)) {
9781 visit_type_bool(v, "restrict", &obj->q_restrict, &err);
9782 if (err) {
9783 goto out;
9784 }
9785 }
9786 if (visit_optional(v, "ipv4", &obj->has_ipv4)) {
9787 visit_type_bool(v, "ipv4", &obj->ipv4, &err);
9788 if (err) {
9789 goto out;
9790 }
9791 }
9792 if (visit_optional(v, "ipv6", &obj->has_ipv6)) {
9793 visit_type_bool(v, "ipv6", &obj->ipv6, &err);
9794 if (err) {
9795 goto out;
9796 }
9797 }
9798 if (visit_optional(v, "ip", &obj->has_ip)) {
9799 visit_type_str(v, "ip", &obj->ip, &err);
9800 if (err) {
9801 goto out;
9802 }
9803 }
9804 if (visit_optional(v, "net", &obj->has_net)) {
9805 visit_type_str(v, "net", &obj->net, &err);
9806 if (err) {
9807 goto out;
9808 }
9809 }
9810 if (visit_optional(v, "host", &obj->has_host)) {
9811 visit_type_str(v, "host", &obj->host, &err);
9812 if (err) {
9813 goto out;
9814 }
9815 }
9816 if (visit_optional(v, "tftp", &obj->has_tftp)) {
9817 visit_type_str(v, "tftp", &obj->tftp, &err);
9818 if (err) {
9819 goto out;
9820 }
9821 }
9822 if (visit_optional(v, "bootfile", &obj->has_bootfile)) {
9823 visit_type_str(v, "bootfile", &obj->bootfile, &err);
9824 if (err) {
9825 goto out;
9826 }
9827 }
9828 if (visit_optional(v, "dhcpstart", &obj->has_dhcpstart)) {
9829 visit_type_str(v, "dhcpstart", &obj->dhcpstart, &err);
9830 if (err) {
9831 goto out;
9832 }
9833 }
9834 if (visit_optional(v, "dns", &obj->has_dns)) {
9835 visit_type_str(v, "dns", &obj->dns, &err);
9836 if (err) {
9837 goto out;
9838 }
9839 }
9840 if (visit_optional(v, "dnssearch", &obj->has_dnssearch)) {
9841 visit_type_StringList(v, "dnssearch", &obj->dnssearch, &err);
9842 if (err) {
9843 goto out;
9844 }
9845 }
9846 if (visit_optional(v, "ipv6-prefix", &obj->has_ipv6_prefix)) {
9847 visit_type_str(v, "ipv6-prefix", &obj->ipv6_prefix, &err);
9848 if (err) {
9849 goto out;
9850 }
9851 }
9852 if (visit_optional(v, "ipv6-prefixlen", &obj->has_ipv6_prefixlen)) {
9853 visit_type_int(v, "ipv6-prefixlen", &obj->ipv6_prefixlen, &err);
9854 if (err) {
9855 goto out;
9856 }
9857 }
9858 if (visit_optional(v, "ipv6-host", &obj->has_ipv6_host)) {
9859 visit_type_str(v, "ipv6-host", &obj->ipv6_host, &err);
9860 if (err) {
9861 goto out;
9862 }
9863 }
9864 if (visit_optional(v, "ipv6-dns", &obj->has_ipv6_dns)) {
9865 visit_type_str(v, "ipv6-dns", &obj->ipv6_dns, &err);
9866 if (err) {
9867 goto out;
9868 }
9869 }
9870 if (visit_optional(v, "smb", &obj->has_smb)) {
9871 visit_type_str(v, "smb", &obj->smb, &err);
9872 if (err) {
9873 goto out;
9874 }
9875 }
9876 if (visit_optional(v, "smbserver", &obj->has_smbserver)) {
9877 visit_type_str(v, "smbserver", &obj->smbserver, &err);
9878 if (err) {
9879 goto out;
9880 }
9881 }
9882 if (visit_optional(v, "hostfwd", &obj->has_hostfwd)) {
9883 visit_type_StringList(v, "hostfwd", &obj->hostfwd, &err);
9884 if (err) {
9885 goto out;
9886 }
9887 }
9888 if (visit_optional(v, "guestfwd", &obj->has_guestfwd)) {
9889 visit_type_StringList(v, "guestfwd", &obj->guestfwd, &err);
9890 if (err) {
9891 goto out;
9892 }
9893 }
9894
9895out:
9896 error_propagate(errp, err);
9897}
9898
9899void visit_type_NetdevUserOptions(Visitor *v, const char *name, NetdevUserOptions **obj, Error **errp)
9900{
9901 Error *err = NULL;
9902
9903 visit_start_struct(v, name, (void **)obj, sizeof(NetdevUserOptions), &err);
9904 if (err) {
9905 goto out;
9906 }
9907 if (!*obj) {
9908 goto out_obj;
9909 }
9910 visit_type_NetdevUserOptions_members(v, *obj, &err);
9911 if (err) {
9912 goto out_obj;
9913 }
9914 visit_check_struct(v, &err);
9915out_obj:
9916 visit_end_struct(v, (void **)obj);
9917 if (err && visit_is_input(v)) {
9918 qapi_free_NetdevUserOptions(*obj);
9919 *obj = NULL;
9920 }
9921out:
9922 error_propagate(errp, err);
9923}
9924
9925void visit_type_NetdevVdeOptions_members(Visitor *v, NetdevVdeOptions *obj, Error **errp)
9926{
9927 Error *err = NULL;
9928
9929 if (visit_optional(v, "sock", &obj->has_sock)) {
9930 visit_type_str(v, "sock", &obj->sock, &err);
9931 if (err) {
9932 goto out;
9933 }
9934 }
9935 if (visit_optional(v, "port", &obj->has_port)) {
9936 visit_type_uint16(v, "port", &obj->port, &err);
9937 if (err) {
9938 goto out;
9939 }
9940 }
9941 if (visit_optional(v, "group", &obj->has_group)) {
9942 visit_type_str(v, "group", &obj->group, &err);
9943 if (err) {
9944 goto out;
9945 }
9946 }
9947 if (visit_optional(v, "mode", &obj->has_mode)) {
9948 visit_type_uint16(v, "mode", &obj->mode, &err);
9949 if (err) {
9950 goto out;
9951 }
9952 }
9953
9954out:
9955 error_propagate(errp, err);
9956}
9957
9958void visit_type_NetdevVdeOptions(Visitor *v, const char *name, NetdevVdeOptions **obj, Error **errp)
9959{
9960 Error *err = NULL;
9961
9962 visit_start_struct(v, name, (void **)obj, sizeof(NetdevVdeOptions), &err);
9963 if (err) {
9964 goto out;
9965 }
9966 if (!*obj) {
9967 goto out_obj;
9968 }
9969 visit_type_NetdevVdeOptions_members(v, *obj, &err);
9970 if (err) {
9971 goto out_obj;
9972 }
9973 visit_check_struct(v, &err);
9974out_obj:
9975 visit_end_struct(v, (void **)obj);
9976 if (err && visit_is_input(v)) {
9977 qapi_free_NetdevVdeOptions(*obj);
9978 *obj = NULL;
9979 }
9980out:
9981 error_propagate(errp, err);
9982}
9983
9984void visit_type_NetdevVhostUserOptions_members(Visitor *v, NetdevVhostUserOptions *obj, Error **errp)
9985{
9986 Error *err = NULL;
9987
9988 visit_type_str(v, "chardev", &obj->chardev, &err);
9989 if (err) {
9990 goto out;
9991 }
9992 if (visit_optional(v, "vhostforce", &obj->has_vhostforce)) {
9993 visit_type_bool(v, "vhostforce", &obj->vhostforce, &err);
9994 if (err) {
9995 goto out;
9996 }
9997 }
9998 if (visit_optional(v, "queues", &obj->has_queues)) {
9999 visit_type_int(v, "queues", &obj->queues, &err);
10000 if (err) {
10001 goto out;
10002 }
10003 }
10004
10005out:
10006 error_propagate(errp, err);
10007}
10008
10009void visit_type_NetdevVhostUserOptions(Visitor *v, const char *name, NetdevVhostUserOptions **obj, Error **errp)
10010{
10011 Error *err = NULL;
10012
10013 visit_start_struct(v, name, (void **)obj, sizeof(NetdevVhostUserOptions), &err);
10014 if (err) {
10015 goto out;
10016 }
10017 if (!*obj) {
10018 goto out_obj;
10019 }
10020 visit_type_NetdevVhostUserOptions_members(v, *obj, &err);
10021 if (err) {
10022 goto out_obj;
10023 }
10024 visit_check_struct(v, &err);
10025out_obj:
10026 visit_end_struct(v, (void **)obj);
10027 if (err && visit_is_input(v)) {
10028 qapi_free_NetdevVhostUserOptions(*obj);
10029 *obj = NULL;
10030 }
10031out:
10032 error_propagate(errp, err);
10033}
10034
10035void visit_type_NetworkAddressFamily(Visitor *v, const char *name, NetworkAddressFamily *obj, Error **errp)
10036{
10037 int value = *obj;
10038 visit_type_enum(v, name, &value, NetworkAddressFamily_lookup, errp);
10039 *obj = value;
10040}
10041
10042void visit_type_NewImageMode(Visitor *v, const char *name, NewImageMode *obj, Error **errp)
10043{
10044 int value = *obj;
10045 visit_type_enum(v, name, &value, NewImageMode_lookup, errp);
10046 *obj = value;
10047}
10048
10049void visit_type_NumaCpuOptions_members(Visitor *v, NumaCpuOptions *obj, Error **errp)
10050{
10051 Error *err = NULL;
10052
10053 visit_type_CpuInstanceProperties_members(v, (CpuInstanceProperties *)obj, &err);
10054 if (err) {
10055 goto out;
10056 }
10057
10058out:
10059 error_propagate(errp, err);
10060}
10061
10062void visit_type_NumaCpuOptions(Visitor *v, const char *name, NumaCpuOptions **obj, Error **errp)
10063{
10064 Error *err = NULL;
10065
10066 visit_start_struct(v, name, (void **)obj, sizeof(NumaCpuOptions), &err);
10067 if (err) {
10068 goto out;
10069 }
10070 if (!*obj) {
10071 goto out_obj;
10072 }
10073 visit_type_NumaCpuOptions_members(v, *obj, &err);
10074 if (err) {
10075 goto out_obj;
10076 }
10077 visit_check_struct(v, &err);
10078out_obj:
10079 visit_end_struct(v, (void **)obj);
10080 if (err && visit_is_input(v)) {
10081 qapi_free_NumaCpuOptions(*obj);
10082 *obj = NULL;
10083 }
10084out:
10085 error_propagate(errp, err);
10086}
10087
10088void visit_type_NumaDistOptions_members(Visitor *v, NumaDistOptions *obj, Error **errp)
10089{
10090 Error *err = NULL;
10091
10092 visit_type_uint16(v, "src", &obj->src, &err);
10093 if (err) {
10094 goto out;
10095 }
10096 visit_type_uint16(v, "dst", &obj->dst, &err);
10097 if (err) {
10098 goto out;
10099 }
10100 visit_type_uint8(v, "val", &obj->val, &err);
10101 if (err) {
10102 goto out;
10103 }
10104
10105out:
10106 error_propagate(errp, err);
10107}
10108
10109void visit_type_NumaDistOptions(Visitor *v, const char *name, NumaDistOptions **obj, Error **errp)
10110{
10111 Error *err = NULL;
10112
10113 visit_start_struct(v, name, (void **)obj, sizeof(NumaDistOptions), &err);
10114 if (err) {
10115 goto out;
10116 }
10117 if (!*obj) {
10118 goto out_obj;
10119 }
10120 visit_type_NumaDistOptions_members(v, *obj, &err);
10121 if (err) {
10122 goto out_obj;
10123 }
10124 visit_check_struct(v, &err);
10125out_obj:
10126 visit_end_struct(v, (void **)obj);
10127 if (err && visit_is_input(v)) {
10128 qapi_free_NumaDistOptions(*obj);
10129 *obj = NULL;
10130 }
10131out:
10132 error_propagate(errp, err);
10133}
10134
10135void visit_type_NumaNodeOptions_members(Visitor *v, NumaNodeOptions *obj, Error **errp)
10136{
10137 Error *err = NULL;
10138
10139 if (visit_optional(v, "nodeid", &obj->has_nodeid)) {
10140 visit_type_uint16(v, "nodeid", &obj->nodeid, &err);
10141 if (err) {
10142 goto out;
10143 }
10144 }
10145 if (visit_optional(v, "cpus", &obj->has_cpus)) {
10146 visit_type_uint16List(v, "cpus", &obj->cpus, &err);
10147 if (err) {
10148 goto out;
10149 }
10150 }
10151 if (visit_optional(v, "mem", &obj->has_mem)) {
10152 visit_type_size(v, "mem", &obj->mem, &err);
10153 if (err) {
10154 goto out;
10155 }
10156 }
10157 if (visit_optional(v, "memdev", &obj->has_memdev)) {
10158 visit_type_str(v, "memdev", &obj->memdev, &err);
10159 if (err) {
10160 goto out;
10161 }
10162 }
10163
10164out:
10165 error_propagate(errp, err);
10166}
10167
10168void visit_type_NumaNodeOptions(Visitor *v, const char *name, NumaNodeOptions **obj, Error **errp)
10169{
10170 Error *err = NULL;
10171
10172 visit_start_struct(v, name, (void **)obj, sizeof(NumaNodeOptions), &err);
10173 if (err) {
10174 goto out;
10175 }
10176 if (!*obj) {
10177 goto out_obj;
10178 }
10179 visit_type_NumaNodeOptions_members(v, *obj, &err);
10180 if (err) {
10181 goto out_obj;
10182 }
10183 visit_check_struct(v, &err);
10184out_obj:
10185 visit_end_struct(v, (void **)obj);
10186 if (err && visit_is_input(v)) {
10187 qapi_free_NumaNodeOptions(*obj);
10188 *obj = NULL;
10189 }
10190out:
10191 error_propagate(errp, err);
10192}
10193
10194void visit_type_NumaOptions_members(Visitor *v, NumaOptions *obj, Error **errp)
10195{
10196 Error *err = NULL;
10197
10198 visit_type_q_obj_NumaOptions_base_members(v, (q_obj_NumaOptions_base *)obj, &err);
10199 if (err) {
10200 goto out;
10201 }
10202 switch (obj->type) {
10203 case NUMA_OPTIONS_TYPE_NODE:
10204 visit_type_NumaNodeOptions_members(v, &obj->u.node, &err);
10205 break;
10206 case NUMA_OPTIONS_TYPE_DIST:
10207 visit_type_NumaDistOptions_members(v, &obj->u.dist, &err);
10208 break;
10209 case NUMA_OPTIONS_TYPE_CPU:
10210 visit_type_NumaCpuOptions_members(v, &obj->u.cpu, &err);
10211 break;
10212 default:
10213 abort();
10214 }
10215
10216out:
10217 error_propagate(errp, err);
10218}
10219
10220void visit_type_NumaOptions(Visitor *v, const char *name, NumaOptions **obj, Error **errp)
10221{
10222 Error *err = NULL;
10223
10224 visit_start_struct(v, name, (void **)obj, sizeof(NumaOptions), &err);
10225 if (err) {
10226 goto out;
10227 }
10228 if (!*obj) {
10229 goto out_obj;
10230 }
10231 visit_type_NumaOptions_members(v, *obj, &err);
10232 if (err) {
10233 goto out_obj;
10234 }
10235 visit_check_struct(v, &err);
10236out_obj:
10237 visit_end_struct(v, (void **)obj);
10238 if (err && visit_is_input(v)) {
10239 qapi_free_NumaOptions(*obj);
10240 *obj = NULL;
10241 }
10242out:
10243 error_propagate(errp, err);
10244}
10245
10246void visit_type_NumaOptionsType(Visitor *v, const char *name, NumaOptionsType *obj, Error **errp)
10247{
10248 int value = *obj;
10249 visit_type_enum(v, name, &value, NumaOptionsType_lookup, errp);
10250 *obj = value;
10251}
10252
10253void visit_type_ObjectPropertyInfo_members(Visitor *v, ObjectPropertyInfo *obj, Error **errp)
10254{
10255 Error *err = NULL;
10256
10257 visit_type_str(v, "name", &obj->name, &err);
10258 if (err) {
10259 goto out;
10260 }
10261 visit_type_str(v, "type", &obj->type, &err);
10262 if (err) {
10263 goto out;
10264 }
10265
10266out:
10267 error_propagate(errp, err);
10268}
10269
10270void visit_type_ObjectPropertyInfo(Visitor *v, const char *name, ObjectPropertyInfo **obj, Error **errp)
10271{
10272 Error *err = NULL;
10273
10274 visit_start_struct(v, name, (void **)obj, sizeof(ObjectPropertyInfo), &err);
10275 if (err) {
10276 goto out;
10277 }
10278 if (!*obj) {
10279 goto out_obj;
10280 }
10281 visit_type_ObjectPropertyInfo_members(v, *obj, &err);
10282 if (err) {
10283 goto out_obj;
10284 }
10285 visit_check_struct(v, &err);
10286out_obj:
10287 visit_end_struct(v, (void **)obj);
10288 if (err && visit_is_input(v)) {
10289 qapi_free_ObjectPropertyInfo(*obj);
10290 *obj = NULL;
10291 }
10292out:
10293 error_propagate(errp, err);
10294}
10295
10296void visit_type_ObjectPropertyInfoList(Visitor *v, const char *name, ObjectPropertyInfoList **obj, Error **errp)
10297{
10298 Error *err = NULL;
10299 ObjectPropertyInfoList *tail;
10300 size_t size = sizeof(**obj);
10301
10302 visit_start_list(v, name, (GenericList **)obj, size, &err);
10303 if (err) {
10304 goto out;
10305 }
10306
10307 for (tail = *obj; tail;
10308 tail = (ObjectPropertyInfoList *)visit_next_list(v, (GenericList *)tail, size)) {
10309 visit_type_ObjectPropertyInfo(v, NULL, &tail->value, &err);
10310 if (err) {
10311 break;
10312 }
10313 }
10314
10315 if (!err) {
10316 visit_check_list(v, &err);
10317 }
10318 visit_end_list(v, (void **)obj);
10319 if (err && visit_is_input(v)) {
10320 qapi_free_ObjectPropertyInfoList(*obj);
10321 *obj = NULL;
10322 }
10323out:
10324 error_propagate(errp, err);
10325}
10326
10327void visit_type_ObjectTypeInfo_members(Visitor *v, ObjectTypeInfo *obj, Error **errp)
10328{
10329 Error *err = NULL;
10330
10331 visit_type_str(v, "name", &obj->name, &err);
10332 if (err) {
10333 goto out;
10334 }
10335 if (visit_optional(v, "abstract", &obj->has_abstract)) {
10336 visit_type_bool(v, "abstract", &obj->abstract, &err);
10337 if (err) {
10338 goto out;
10339 }
10340 }
10341 if (visit_optional(v, "parent", &obj->has_parent)) {
10342 visit_type_str(v, "parent", &obj->parent, &err);
10343 if (err) {
10344 goto out;
10345 }
10346 }
10347
10348out:
10349 error_propagate(errp, err);
10350}
10351
10352void visit_type_ObjectTypeInfo(Visitor *v, const char *name, ObjectTypeInfo **obj, Error **errp)
10353{
10354 Error *err = NULL;
10355
10356 visit_start_struct(v, name, (void **)obj, sizeof(ObjectTypeInfo), &err);
10357 if (err) {
10358 goto out;
10359 }
10360 if (!*obj) {
10361 goto out_obj;
10362 }
10363 visit_type_ObjectTypeInfo_members(v, *obj, &err);
10364 if (err) {
10365 goto out_obj;
10366 }
10367 visit_check_struct(v, &err);
10368out_obj:
10369 visit_end_struct(v, (void **)obj);
10370 if (err && visit_is_input(v)) {
10371 qapi_free_ObjectTypeInfo(*obj);
10372 *obj = NULL;
10373 }
10374out:
10375 error_propagate(errp, err);
10376}
10377
10378void visit_type_ObjectTypeInfoList(Visitor *v, const char *name, ObjectTypeInfoList **obj, Error **errp)
10379{
10380 Error *err = NULL;
10381 ObjectTypeInfoList *tail;
10382 size_t size = sizeof(**obj);
10383
10384 visit_start_list(v, name, (GenericList **)obj, size, &err);
10385 if (err) {
10386 goto out;
10387 }
10388
10389 for (tail = *obj; tail;
10390 tail = (ObjectTypeInfoList *)visit_next_list(v, (GenericList *)tail, size)) {
10391 visit_type_ObjectTypeInfo(v, NULL, &tail->value, &err);
10392 if (err) {
10393 break;
10394 }
10395 }
10396
10397 if (!err) {
10398 visit_check_list(v, &err);
10399 }
10400 visit_end_list(v, (void **)obj);
10401 if (err && visit_is_input(v)) {
10402 qapi_free_ObjectTypeInfoList(*obj);
10403 *obj = NULL;
10404 }
10405out:
10406 error_propagate(errp, err);
10407}
10408
10409void visit_type_OnOffAuto(Visitor *v, const char *name, OnOffAuto *obj, Error **errp)
10410{
10411 int value = *obj;
10412 visit_type_enum(v, name, &value, OnOffAuto_lookup, errp);
10413 *obj = value;
10414}
10415
10416void visit_type_OnOffSplit(Visitor *v, const char *name, OnOffSplit *obj, Error **errp)
10417{
10418 int value = *obj;
10419 visit_type_enum(v, name, &value, OnOffSplit_lookup, errp);
10420 *obj = value;
10421}
10422
10423void visit_type_PCDIMMDeviceInfo_members(Visitor *v, PCDIMMDeviceInfo *obj, Error **errp)
10424{
10425 Error *err = NULL;
10426
10427 if (visit_optional(v, "id", &obj->has_id)) {
10428 visit_type_str(v, "id", &obj->id, &err);
10429 if (err) {
10430 goto out;
10431 }
10432 }
10433 visit_type_int(v, "addr", &obj->addr, &err);
10434 if (err) {
10435 goto out;
10436 }
10437 visit_type_int(v, "size", &obj->size, &err);
10438 if (err) {
10439 goto out;
10440 }
10441 visit_type_int(v, "slot", &obj->slot, &err);
10442 if (err) {
10443 goto out;
10444 }
10445 visit_type_int(v, "node", &obj->node, &err);
10446 if (err) {
10447 goto out;
10448 }
10449 visit_type_str(v, "memdev", &obj->memdev, &err);
10450 if (err) {
10451 goto out;
10452 }
10453 visit_type_bool(v, "hotplugged", &obj->hotplugged, &err);
10454 if (err) {
10455 goto out;
10456 }
10457 visit_type_bool(v, "hotpluggable", &obj->hotpluggable, &err);
10458 if (err) {
10459 goto out;
10460 }
10461
10462out:
10463 error_propagate(errp, err);
10464}
10465
10466void visit_type_PCDIMMDeviceInfo(Visitor *v, const char *name, PCDIMMDeviceInfo **obj, Error **errp)
10467{
10468 Error *err = NULL;
10469
10470 visit_start_struct(v, name, (void **)obj, sizeof(PCDIMMDeviceInfo), &err);
10471 if (err) {
10472 goto out;
10473 }
10474 if (!*obj) {
10475 goto out_obj;
10476 }
10477 visit_type_PCDIMMDeviceInfo_members(v, *obj, &err);
10478 if (err) {
10479 goto out_obj;
10480 }
10481 visit_check_struct(v, &err);
10482out_obj:
10483 visit_end_struct(v, (void **)obj);
10484 if (err && visit_is_input(v)) {
10485 qapi_free_PCDIMMDeviceInfo(*obj);
10486 *obj = NULL;
10487 }
10488out:
10489 error_propagate(errp, err);
10490}
10491
10492void visit_type_PciBridgeInfo_members(Visitor *v, PciBridgeInfo *obj, Error **errp)
10493{
10494 Error *err = NULL;
10495
10496 visit_type_PciBusInfo(v, "bus", &obj->bus, &err);
10497 if (err) {
10498 goto out;
10499 }
10500 if (visit_optional(v, "devices", &obj->has_devices)) {
10501 visit_type_PciDeviceInfoList(v, "devices", &obj->devices, &err);
10502 if (err) {
10503 goto out;
10504 }
10505 }
10506
10507out:
10508 error_propagate(errp, err);
10509}
10510
10511void visit_type_PciBridgeInfo(Visitor *v, const char *name, PciBridgeInfo **obj, Error **errp)
10512{
10513 Error *err = NULL;
10514
10515 visit_start_struct(v, name, (void **)obj, sizeof(PciBridgeInfo), &err);
10516 if (err) {
10517 goto out;
10518 }
10519 if (!*obj) {
10520 goto out_obj;
10521 }
10522 visit_type_PciBridgeInfo_members(v, *obj, &err);
10523 if (err) {
10524 goto out_obj;
10525 }
10526 visit_check_struct(v, &err);
10527out_obj:
10528 visit_end_struct(v, (void **)obj);
10529 if (err && visit_is_input(v)) {
10530 qapi_free_PciBridgeInfo(*obj);
10531 *obj = NULL;
10532 }
10533out:
10534 error_propagate(errp, err);
10535}
10536
10537void visit_type_PciBusInfo_members(Visitor *v, PciBusInfo *obj, Error **errp)
10538{
10539 Error *err = NULL;
10540
10541 visit_type_int(v, "number", &obj->number, &err);
10542 if (err) {
10543 goto out;
10544 }
10545 visit_type_int(v, "secondary", &obj->secondary, &err);
10546 if (err) {
10547 goto out;
10548 }
10549 visit_type_int(v, "subordinate", &obj->subordinate, &err);
10550 if (err) {
10551 goto out;
10552 }
10553 visit_type_PciMemoryRange(v, "io_range", &obj->io_range, &err);
10554 if (err) {
10555 goto out;
10556 }
10557 visit_type_PciMemoryRange(v, "memory_range", &obj->memory_range, &err);
10558 if (err) {
10559 goto out;
10560 }
10561 visit_type_PciMemoryRange(v, "prefetchable_range", &obj->prefetchable_range, &err);
10562 if (err) {
10563 goto out;
10564 }
10565
10566out:
10567 error_propagate(errp, err);
10568}
10569
10570void visit_type_PciBusInfo(Visitor *v, const char *name, PciBusInfo **obj, Error **errp)
10571{
10572 Error *err = NULL;
10573
10574 visit_start_struct(v, name, (void **)obj, sizeof(PciBusInfo), &err);
10575 if (err) {
10576 goto out;
10577 }
10578 if (!*obj) {
10579 goto out_obj;
10580 }
10581 visit_type_PciBusInfo_members(v, *obj, &err);
10582 if (err) {
10583 goto out_obj;
10584 }
10585 visit_check_struct(v, &err);
10586out_obj:
10587 visit_end_struct(v, (void **)obj);
10588 if (err && visit_is_input(v)) {
10589 qapi_free_PciBusInfo(*obj);
10590 *obj = NULL;
10591 }
10592out:
10593 error_propagate(errp, err);
10594}
10595
10596void visit_type_PciDeviceClass_members(Visitor *v, PciDeviceClass *obj, Error **errp)
10597{
10598 Error *err = NULL;
10599
10600 if (visit_optional(v, "desc", &obj->has_desc)) {
10601 visit_type_str(v, "desc", &obj->desc, &err);
10602 if (err) {
10603 goto out;
10604 }
10605 }
10606 visit_type_int(v, "class", &obj->q_class, &err);
10607 if (err) {
10608 goto out;
10609 }
10610
10611out:
10612 error_propagate(errp, err);
10613}
10614
10615void visit_type_PciDeviceClass(Visitor *v, const char *name, PciDeviceClass **obj, Error **errp)
10616{
10617 Error *err = NULL;
10618
10619 visit_start_struct(v, name, (void **)obj, sizeof(PciDeviceClass), &err);
10620 if (err) {
10621 goto out;
10622 }
10623 if (!*obj) {
10624 goto out_obj;
10625 }
10626 visit_type_PciDeviceClass_members(v, *obj, &err);
10627 if (err) {
10628 goto out_obj;
10629 }
10630 visit_check_struct(v, &err);
10631out_obj:
10632 visit_end_struct(v, (void **)obj);
10633 if (err && visit_is_input(v)) {
10634 qapi_free_PciDeviceClass(*obj);
10635 *obj = NULL;
10636 }
10637out:
10638 error_propagate(errp, err);
10639}
10640
10641void visit_type_PciDeviceId_members(Visitor *v, PciDeviceId *obj, Error **errp)
10642{
10643 Error *err = NULL;
10644
10645 visit_type_int(v, "device", &obj->device, &err);
10646 if (err) {
10647 goto out;
10648 }
10649 visit_type_int(v, "vendor", &obj->vendor, &err);
10650 if (err) {
10651 goto out;
10652 }
10653
10654out:
10655 error_propagate(errp, err);
10656}
10657
10658void visit_type_PciDeviceId(Visitor *v, const char *name, PciDeviceId **obj, Error **errp)
10659{
10660 Error *err = NULL;
10661
10662 visit_start_struct(v, name, (void **)obj, sizeof(PciDeviceId), &err);
10663 if (err) {
10664 goto out;
10665 }
10666 if (!*obj) {
10667 goto out_obj;
10668 }
10669 visit_type_PciDeviceId_members(v, *obj, &err);
10670 if (err) {
10671 goto out_obj;
10672 }
10673 visit_check_struct(v, &err);
10674out_obj:
10675 visit_end_struct(v, (void **)obj);
10676 if (err && visit_is_input(v)) {
10677 qapi_free_PciDeviceId(*obj);
10678 *obj = NULL;
10679 }
10680out:
10681 error_propagate(errp, err);
10682}
10683
10684void visit_type_PciDeviceInfo_members(Visitor *v, PciDeviceInfo *obj, Error **errp)
10685{
10686 Error *err = NULL;
10687
10688 visit_type_int(v, "bus", &obj->bus, &err);
10689 if (err) {
10690 goto out;
10691 }
10692 visit_type_int(v, "slot", &obj->slot, &err);
10693 if (err) {
10694 goto out;
10695 }
10696 visit_type_int(v, "function", &obj->function, &err);
10697 if (err) {
10698 goto out;
10699 }
10700 visit_type_PciDeviceClass(v, "class_info", &obj->class_info, &err);
10701 if (err) {
10702 goto out;
10703 }
10704 visit_type_PciDeviceId(v, "id", &obj->id, &err);
10705 if (err) {
10706 goto out;
10707 }
10708 if (visit_optional(v, "irq", &obj->has_irq)) {
10709 visit_type_int(v, "irq", &obj->irq, &err);
10710 if (err) {
10711 goto out;
10712 }
10713 }
10714 visit_type_str(v, "qdev_id", &obj->qdev_id, &err);
10715 if (err) {
10716 goto out;
10717 }
10718 if (visit_optional(v, "pci_bridge", &obj->has_pci_bridge)) {
10719 visit_type_PciBridgeInfo(v, "pci_bridge", &obj->pci_bridge, &err);
10720 if (err) {
10721 goto out;
10722 }
10723 }
10724 visit_type_PciMemoryRegionList(v, "regions", &obj->regions, &err);
10725 if (err) {
10726 goto out;
10727 }
10728
10729out:
10730 error_propagate(errp, err);
10731}
10732
10733void visit_type_PciDeviceInfo(Visitor *v, const char *name, PciDeviceInfo **obj, Error **errp)
10734{
10735 Error *err = NULL;
10736
10737 visit_start_struct(v, name, (void **)obj, sizeof(PciDeviceInfo), &err);
10738 if (err) {
10739 goto out;
10740 }
10741 if (!*obj) {
10742 goto out_obj;
10743 }
10744 visit_type_PciDeviceInfo_members(v, *obj, &err);
10745 if (err) {
10746 goto out_obj;
10747 }
10748 visit_check_struct(v, &err);
10749out_obj:
10750 visit_end_struct(v, (void **)obj);
10751 if (err && visit_is_input(v)) {
10752 qapi_free_PciDeviceInfo(*obj);
10753 *obj = NULL;
10754 }
10755out:
10756 error_propagate(errp, err);
10757}
10758
10759void visit_type_PciDeviceInfoList(Visitor *v, const char *name, PciDeviceInfoList **obj, Error **errp)
10760{
10761 Error *err = NULL;
10762 PciDeviceInfoList *tail;
10763 size_t size = sizeof(**obj);
10764
10765 visit_start_list(v, name, (GenericList **)obj, size, &err);
10766 if (err) {
10767 goto out;
10768 }
10769
10770 for (tail = *obj; tail;
10771 tail = (PciDeviceInfoList *)visit_next_list(v, (GenericList *)tail, size)) {
10772 visit_type_PciDeviceInfo(v, NULL, &tail->value, &err);
10773 if (err) {
10774 break;
10775 }
10776 }
10777
10778 if (!err) {
10779 visit_check_list(v, &err);
10780 }
10781 visit_end_list(v, (void **)obj);
10782 if (err && visit_is_input(v)) {
10783 qapi_free_PciDeviceInfoList(*obj);
10784 *obj = NULL;
10785 }
10786out:
10787 error_propagate(errp, err);
10788}
10789
10790void visit_type_PciInfo_members(Visitor *v, PciInfo *obj, Error **errp)
10791{
10792 Error *err = NULL;
10793
10794 visit_type_int(v, "bus", &obj->bus, &err);
10795 if (err) {
10796 goto out;
10797 }
10798 visit_type_PciDeviceInfoList(v, "devices", &obj->devices, &err);
10799 if (err) {
10800 goto out;
10801 }
10802
10803out:
10804 error_propagate(errp, err);
10805}
10806
10807void visit_type_PciInfo(Visitor *v, const char *name, PciInfo **obj, Error **errp)
10808{
10809 Error *err = NULL;
10810
10811 visit_start_struct(v, name, (void **)obj, sizeof(PciInfo), &err);
10812 if (err) {
10813 goto out;
10814 }
10815 if (!*obj) {
10816 goto out_obj;
10817 }
10818 visit_type_PciInfo_members(v, *obj, &err);
10819 if (err) {
10820 goto out_obj;
10821 }
10822 visit_check_struct(v, &err);
10823out_obj:
10824 visit_end_struct(v, (void **)obj);
10825 if (err && visit_is_input(v)) {
10826 qapi_free_PciInfo(*obj);
10827 *obj = NULL;
10828 }
10829out:
10830 error_propagate(errp, err);
10831}
10832
10833void visit_type_PciInfoList(Visitor *v, const char *name, PciInfoList **obj, Error **errp)
10834{
10835 Error *err = NULL;
10836 PciInfoList *tail;
10837 size_t size = sizeof(**obj);
10838
10839 visit_start_list(v, name, (GenericList **)obj, size, &err);
10840 if (err) {
10841 goto out;
10842 }
10843
10844 for (tail = *obj; tail;
10845 tail = (PciInfoList *)visit_next_list(v, (GenericList *)tail, size)) {
10846 visit_type_PciInfo(v, NULL, &tail->value, &err);
10847 if (err) {
10848 break;
10849 }
10850 }
10851
10852 if (!err) {
10853 visit_check_list(v, &err);
10854 }
10855 visit_end_list(v, (void **)obj);
10856 if (err && visit_is_input(v)) {
10857 qapi_free_PciInfoList(*obj);
10858 *obj = NULL;
10859 }
10860out:
10861 error_propagate(errp, err);
10862}
10863
10864void visit_type_PciMemoryRange_members(Visitor *v, PciMemoryRange *obj, Error **errp)
10865{
10866 Error *err = NULL;
10867
10868 visit_type_int(v, "base", &obj->base, &err);
10869 if (err) {
10870 goto out;
10871 }
10872 visit_type_int(v, "limit", &obj->limit, &err);
10873 if (err) {
10874 goto out;
10875 }
10876
10877out:
10878 error_propagate(errp, err);
10879}
10880
10881void visit_type_PciMemoryRange(Visitor *v, const char *name, PciMemoryRange **obj, Error **errp)
10882{
10883 Error *err = NULL;
10884
10885 visit_start_struct(v, name, (void **)obj, sizeof(PciMemoryRange), &err);
10886 if (err) {
10887 goto out;
10888 }
10889 if (!*obj) {
10890 goto out_obj;
10891 }
10892 visit_type_PciMemoryRange_members(v, *obj, &err);
10893 if (err) {
10894 goto out_obj;
10895 }
10896 visit_check_struct(v, &err);
10897out_obj:
10898 visit_end_struct(v, (void **)obj);
10899 if (err && visit_is_input(v)) {
10900 qapi_free_PciMemoryRange(*obj);
10901 *obj = NULL;
10902 }
10903out:
10904 error_propagate(errp, err);
10905}
10906
10907void visit_type_PciMemoryRegion_members(Visitor *v, PciMemoryRegion *obj, Error **errp)
10908{
10909 Error *err = NULL;
10910
10911 visit_type_int(v, "bar", &obj->bar, &err);
10912 if (err) {
10913 goto out;
10914 }
10915 visit_type_str(v, "type", &obj->type, &err);
10916 if (err) {
10917 goto out;
10918 }
10919 visit_type_int(v, "address", &obj->address, &err);
10920 if (err) {
10921 goto out;
10922 }
10923 visit_type_int(v, "size", &obj->size, &err);
10924 if (err) {
10925 goto out;
10926 }
10927 if (visit_optional(v, "prefetch", &obj->has_prefetch)) {
10928 visit_type_bool(v, "prefetch", &obj->prefetch, &err);
10929 if (err) {
10930 goto out;
10931 }
10932 }
10933 if (visit_optional(v, "mem_type_64", &obj->has_mem_type_64)) {
10934 visit_type_bool(v, "mem_type_64", &obj->mem_type_64, &err);
10935 if (err) {
10936 goto out;
10937 }
10938 }
10939
10940out:
10941 error_propagate(errp, err);
10942}
10943
10944void visit_type_PciMemoryRegion(Visitor *v, const char *name, PciMemoryRegion **obj, Error **errp)
10945{
10946 Error *err = NULL;
10947
10948 visit_start_struct(v, name, (void **)obj, sizeof(PciMemoryRegion), &err);
10949 if (err) {
10950 goto out;
10951 }
10952 if (!*obj) {
10953 goto out_obj;
10954 }
10955 visit_type_PciMemoryRegion_members(v, *obj, &err);
10956 if (err) {
10957 goto out_obj;
10958 }
10959 visit_check_struct(v, &err);
10960out_obj:
10961 visit_end_struct(v, (void **)obj);
10962 if (err && visit_is_input(v)) {
10963 qapi_free_PciMemoryRegion(*obj);
10964 *obj = NULL;
10965 }
10966out:
10967 error_propagate(errp, err);
10968}
10969
10970void visit_type_PciMemoryRegionList(Visitor *v, const char *name, PciMemoryRegionList **obj, Error **errp)
10971{
10972 Error *err = NULL;
10973 PciMemoryRegionList *tail;
10974 size_t size = sizeof(**obj);
10975
10976 visit_start_list(v, name, (GenericList **)obj, size, &err);
10977 if (err) {
10978 goto out;
10979 }
10980
10981 for (tail = *obj; tail;
10982 tail = (PciMemoryRegionList *)visit_next_list(v, (GenericList *)tail, size)) {
10983 visit_type_PciMemoryRegion(v, NULL, &tail->value, &err);
10984 if (err) {
10985 break;
10986 }
10987 }
10988
10989 if (!err) {
10990 visit_check_list(v, &err);
10991 }
10992 visit_end_list(v, (void **)obj);
10993 if (err && visit_is_input(v)) {
10994 qapi_free_PciMemoryRegionList(*obj);
10995 *obj = NULL;
10996 }
10997out:
10998 error_propagate(errp, err);
10999}
11000
11001void visit_type_PreallocMode(Visitor *v, const char *name, PreallocMode *obj, Error **errp)
11002{
11003 int value = *obj;
11004 visit_type_enum(v, name, &value, PreallocMode_lookup, errp);
11005 *obj = value;
11006}
11007
11008void visit_type_QCryptoBlockCreateOptions_members(Visitor *v, QCryptoBlockCreateOptions *obj, Error **errp)
11009{
11010 Error *err = NULL;
11011
11012 visit_type_QCryptoBlockOptionsBase_members(v, (QCryptoBlockOptionsBase *)obj, &err);
11013 if (err) {
11014 goto out;
11015 }
11016 switch (obj->format) {
11017 case Q_CRYPTO_BLOCK_FORMAT_QCOW:
11018 visit_type_QCryptoBlockOptionsQCow_members(v, &obj->u.qcow, &err);
11019 break;
11020 case Q_CRYPTO_BLOCK_FORMAT_LUKS:
11021 visit_type_QCryptoBlockCreateOptionsLUKS_members(v, &obj->u.luks, &err);
11022 break;
11023 default:
11024 abort();
11025 }
11026
11027out:
11028 error_propagate(errp, err);
11029}
11030
11031void visit_type_QCryptoBlockCreateOptions(Visitor *v, const char *name, QCryptoBlockCreateOptions **obj, Error **errp)
11032{
11033 Error *err = NULL;
11034
11035 visit_start_struct(v, name, (void **)obj, sizeof(QCryptoBlockCreateOptions), &err);
11036 if (err) {
11037 goto out;
11038 }
11039 if (!*obj) {
11040 goto out_obj;
11041 }
11042 visit_type_QCryptoBlockCreateOptions_members(v, *obj, &err);
11043 if (err) {
11044 goto out_obj;
11045 }
11046 visit_check_struct(v, &err);
11047out_obj:
11048 visit_end_struct(v, (void **)obj);
11049 if (err && visit_is_input(v)) {
11050 qapi_free_QCryptoBlockCreateOptions(*obj);
11051 *obj = NULL;
11052 }
11053out:
11054 error_propagate(errp, err);
11055}
11056
11057void visit_type_QCryptoBlockCreateOptionsLUKS_members(Visitor *v, QCryptoBlockCreateOptionsLUKS *obj, Error **errp)
11058{
11059 Error *err = NULL;
11060
11061 visit_type_QCryptoBlockOptionsLUKS_members(v, (QCryptoBlockOptionsLUKS *)obj, &err);
11062 if (err) {
11063 goto out;
11064 }
11065 if (visit_optional(v, "cipher-alg", &obj->has_cipher_alg)) {
11066 visit_type_QCryptoCipherAlgorithm(v, "cipher-alg", &obj->cipher_alg, &err);
11067 if (err) {
11068 goto out;
11069 }
11070 }
11071 if (visit_optional(v, "cipher-mode", &obj->has_cipher_mode)) {
11072 visit_type_QCryptoCipherMode(v, "cipher-mode", &obj->cipher_mode, &err);
11073 if (err) {
11074 goto out;
11075 }
11076 }
11077 if (visit_optional(v, "ivgen-alg", &obj->has_ivgen_alg)) {
11078 visit_type_QCryptoIVGenAlgorithm(v, "ivgen-alg", &obj->ivgen_alg, &err);
11079 if (err) {
11080 goto out;
11081 }
11082 }
11083 if (visit_optional(v, "ivgen-hash-alg", &obj->has_ivgen_hash_alg)) {
11084 visit_type_QCryptoHashAlgorithm(v, "ivgen-hash-alg", &obj->ivgen_hash_alg, &err);
11085 if (err) {
11086 goto out;
11087 }
11088 }
11089 if (visit_optional(v, "hash-alg", &obj->has_hash_alg)) {
11090 visit_type_QCryptoHashAlgorithm(v, "hash-alg", &obj->hash_alg, &err);
11091 if (err) {
11092 goto out;
11093 }
11094 }
11095 if (visit_optional(v, "iter-time", &obj->has_iter_time)) {
11096 visit_type_int(v, "iter-time", &obj->iter_time, &err);
11097 if (err) {
11098 goto out;
11099 }
11100 }
11101
11102out:
11103 error_propagate(errp, err);
11104}
11105
11106void visit_type_QCryptoBlockCreateOptionsLUKS(Visitor *v, const char *name, QCryptoBlockCreateOptionsLUKS **obj, Error **errp)
11107{
11108 Error *err = NULL;
11109
11110 visit_start_struct(v, name, (void **)obj, sizeof(QCryptoBlockCreateOptionsLUKS), &err);
11111 if (err) {
11112 goto out;
11113 }
11114 if (!*obj) {
11115 goto out_obj;
11116 }
11117 visit_type_QCryptoBlockCreateOptionsLUKS_members(v, *obj, &err);
11118 if (err) {
11119 goto out_obj;
11120 }
11121 visit_check_struct(v, &err);
11122out_obj:
11123 visit_end_struct(v, (void **)obj);
11124 if (err && visit_is_input(v)) {
11125 qapi_free_QCryptoBlockCreateOptionsLUKS(*obj);
11126 *obj = NULL;
11127 }
11128out:
11129 error_propagate(errp, err);
11130}
11131
11132void visit_type_QCryptoBlockFormat(Visitor *v, const char *name, QCryptoBlockFormat *obj, Error **errp)
11133{
11134 int value = *obj;
11135 visit_type_enum(v, name, &value, QCryptoBlockFormat_lookup, errp);
11136 *obj = value;
11137}
11138
11139void visit_type_QCryptoBlockInfo_members(Visitor *v, QCryptoBlockInfo *obj, Error **errp)
11140{
11141 Error *err = NULL;
11142
11143 visit_type_QCryptoBlockInfoBase_members(v, (QCryptoBlockInfoBase *)obj, &err);
11144 if (err) {
11145 goto out;
11146 }
11147 switch (obj->format) {
11148 case Q_CRYPTO_BLOCK_FORMAT_QCOW:
11149 visit_type_QCryptoBlockInfoQCow_members(v, &obj->u.qcow, &err);
11150 break;
11151 case Q_CRYPTO_BLOCK_FORMAT_LUKS:
11152 visit_type_QCryptoBlockInfoLUKS_members(v, &obj->u.luks, &err);
11153 break;
11154 default:
11155 abort();
11156 }
11157
11158out:
11159 error_propagate(errp, err);
11160}
11161
11162void visit_type_QCryptoBlockInfo(Visitor *v, const char *name, QCryptoBlockInfo **obj, Error **errp)
11163{
11164 Error *err = NULL;
11165
11166 visit_start_struct(v, name, (void **)obj, sizeof(QCryptoBlockInfo), &err);
11167 if (err) {
11168 goto out;
11169 }
11170 if (!*obj) {
11171 goto out_obj;
11172 }
11173 visit_type_QCryptoBlockInfo_members(v, *obj, &err);
11174 if (err) {
11175 goto out_obj;
11176 }
11177 visit_check_struct(v, &err);
11178out_obj:
11179 visit_end_struct(v, (void **)obj);
11180 if (err && visit_is_input(v)) {
11181 qapi_free_QCryptoBlockInfo(*obj);
11182 *obj = NULL;
11183 }
11184out:
11185 error_propagate(errp, err);
11186}
11187
11188void visit_type_QCryptoBlockInfoBase_members(Visitor *v, QCryptoBlockInfoBase *obj, Error **errp)
11189{
11190 Error *err = NULL;
11191
11192 visit_type_QCryptoBlockFormat(v, "format", &obj->format, &err);
11193 if (err) {
11194 goto out;
11195 }
11196
11197out:
11198 error_propagate(errp, err);
11199}
11200
11201void visit_type_QCryptoBlockInfoBase(Visitor *v, const char *name, QCryptoBlockInfoBase **obj, Error **errp)
11202{
11203 Error *err = NULL;
11204
11205 visit_start_struct(v, name, (void **)obj, sizeof(QCryptoBlockInfoBase), &err);
11206 if (err) {
11207 goto out;
11208 }
11209 if (!*obj) {
11210 goto out_obj;
11211 }
11212 visit_type_QCryptoBlockInfoBase_members(v, *obj, &err);
11213 if (err) {
11214 goto out_obj;
11215 }
11216 visit_check_struct(v, &err);
11217out_obj:
11218 visit_end_struct(v, (void **)obj);
11219 if (err && visit_is_input(v)) {
11220 qapi_free_QCryptoBlockInfoBase(*obj);
11221 *obj = NULL;
11222 }
11223out:
11224 error_propagate(errp, err);
11225}
11226
11227void visit_type_QCryptoBlockInfoLUKS_members(Visitor *v, QCryptoBlockInfoLUKS *obj, Error **errp)
11228{
11229 Error *err = NULL;
11230
11231 visit_type_QCryptoCipherAlgorithm(v, "cipher-alg", &obj->cipher_alg, &err);
11232 if (err) {
11233 goto out;
11234 }
11235 visit_type_QCryptoCipherMode(v, "cipher-mode", &obj->cipher_mode, &err);
11236 if (err) {
11237 goto out;
11238 }
11239 visit_type_QCryptoIVGenAlgorithm(v, "ivgen-alg", &obj->ivgen_alg, &err);
11240 if (err) {
11241 goto out;
11242 }
11243 if (visit_optional(v, "ivgen-hash-alg", &obj->has_ivgen_hash_alg)) {
11244 visit_type_QCryptoHashAlgorithm(v, "ivgen-hash-alg", &obj->ivgen_hash_alg, &err);
11245 if (err) {
11246 goto out;
11247 }
11248 }
11249 visit_type_QCryptoHashAlgorithm(v, "hash-alg", &obj->hash_alg, &err);
11250 if (err) {
11251 goto out;
11252 }
11253 visit_type_int(v, "payload-offset", &obj->payload_offset, &err);
11254 if (err) {
11255 goto out;
11256 }
11257 visit_type_int(v, "master-key-iters", &obj->master_key_iters, &err);
11258 if (err) {
11259 goto out;
11260 }
11261 visit_type_str(v, "uuid", &obj->uuid, &err);
11262 if (err) {
11263 goto out;
11264 }
11265 visit_type_QCryptoBlockInfoLUKSSlotList(v, "slots", &obj->slots, &err);
11266 if (err) {
11267 goto out;
11268 }
11269
11270out:
11271 error_propagate(errp, err);
11272}
11273
11274void visit_type_QCryptoBlockInfoLUKS(Visitor *v, const char *name, QCryptoBlockInfoLUKS **obj, Error **errp)
11275{
11276 Error *err = NULL;
11277
11278 visit_start_struct(v, name, (void **)obj, sizeof(QCryptoBlockInfoLUKS), &err);
11279 if (err) {
11280 goto out;
11281 }
11282 if (!*obj) {
11283 goto out_obj;
11284 }
11285 visit_type_QCryptoBlockInfoLUKS_members(v, *obj, &err);
11286 if (err) {
11287 goto out_obj;
11288 }
11289 visit_check_struct(v, &err);
11290out_obj:
11291 visit_end_struct(v, (void **)obj);
11292 if (err && visit_is_input(v)) {
11293 qapi_free_QCryptoBlockInfoLUKS(*obj);
11294 *obj = NULL;
11295 }
11296out:
11297 error_propagate(errp, err);
11298}
11299
11300void visit_type_QCryptoBlockInfoLUKSSlot_members(Visitor *v, QCryptoBlockInfoLUKSSlot *obj, Error **errp)
11301{
11302 Error *err = NULL;
11303
11304 visit_type_bool(v, "active", &obj->active, &err);
11305 if (err) {
11306 goto out;
11307 }
11308 if (visit_optional(v, "iters", &obj->has_iters)) {
11309 visit_type_int(v, "iters", &obj->iters, &err);
11310 if (err) {
11311 goto out;
11312 }
11313 }
11314 if (visit_optional(v, "stripes", &obj->has_stripes)) {
11315 visit_type_int(v, "stripes", &obj->stripes, &err);
11316 if (err) {
11317 goto out;
11318 }
11319 }
11320 visit_type_int(v, "key-offset", &obj->key_offset, &err);
11321 if (err) {
11322 goto out;
11323 }
11324
11325out:
11326 error_propagate(errp, err);
11327}
11328
11329void visit_type_QCryptoBlockInfoLUKSSlot(Visitor *v, const char *name, QCryptoBlockInfoLUKSSlot **obj, Error **errp)
11330{
11331 Error *err = NULL;
11332
11333 visit_start_struct(v, name, (void **)obj, sizeof(QCryptoBlockInfoLUKSSlot), &err);
11334 if (err) {
11335 goto out;
11336 }
11337 if (!*obj) {
11338 goto out_obj;
11339 }
11340 visit_type_QCryptoBlockInfoLUKSSlot_members(v, *obj, &err);
11341 if (err) {
11342 goto out_obj;
11343 }
11344 visit_check_struct(v, &err);
11345out_obj:
11346 visit_end_struct(v, (void **)obj);
11347 if (err && visit_is_input(v)) {
11348 qapi_free_QCryptoBlockInfoLUKSSlot(*obj);
11349 *obj = NULL;
11350 }
11351out:
11352 error_propagate(errp, err);
11353}
11354
11355void visit_type_QCryptoBlockInfoLUKSSlotList(Visitor *v, const char *name, QCryptoBlockInfoLUKSSlotList **obj, Error **errp)
11356{
11357 Error *err = NULL;
11358 QCryptoBlockInfoLUKSSlotList *tail;
11359 size_t size = sizeof(**obj);
11360
11361 visit_start_list(v, name, (GenericList **)obj, size, &err);
11362 if (err) {
11363 goto out;
11364 }
11365
11366 for (tail = *obj; tail;
11367 tail = (QCryptoBlockInfoLUKSSlotList *)visit_next_list(v, (GenericList *)tail, size)) {
11368 visit_type_QCryptoBlockInfoLUKSSlot(v, NULL, &tail->value, &err);
11369 if (err) {
11370 break;
11371 }
11372 }
11373
11374 if (!err) {
11375 visit_check_list(v, &err);
11376 }
11377 visit_end_list(v, (void **)obj);
11378 if (err && visit_is_input(v)) {
11379 qapi_free_QCryptoBlockInfoLUKSSlotList(*obj);
11380 *obj = NULL;
11381 }
11382out:
11383 error_propagate(errp, err);
11384}
11385
11386void visit_type_QCryptoBlockInfoQCow_members(Visitor *v, QCryptoBlockInfoQCow *obj, Error **errp)
11387{
11388 Error *err = NULL;
11389
11390 error_propagate(errp, err);
11391}
11392
11393void visit_type_QCryptoBlockInfoQCow(Visitor *v, const char *name, QCryptoBlockInfoQCow **obj, Error **errp)
11394{
11395 Error *err = NULL;
11396
11397 visit_start_struct(v, name, (void **)obj, sizeof(QCryptoBlockInfoQCow), &err);
11398 if (err) {
11399 goto out;
11400 }
11401 if (!*obj) {
11402 goto out_obj;
11403 }
11404 visit_type_QCryptoBlockInfoQCow_members(v, *obj, &err);
11405 if (err) {
11406 goto out_obj;
11407 }
11408 visit_check_struct(v, &err);
11409out_obj:
11410 visit_end_struct(v, (void **)obj);
11411 if (err && visit_is_input(v)) {
11412 qapi_free_QCryptoBlockInfoQCow(*obj);
11413 *obj = NULL;
11414 }
11415out:
11416 error_propagate(errp, err);
11417}
11418
11419void visit_type_QCryptoBlockOpenOptions_members(Visitor *v, QCryptoBlockOpenOptions *obj, Error **errp)
11420{
11421 Error *err = NULL;
11422
11423 visit_type_QCryptoBlockOptionsBase_members(v, (QCryptoBlockOptionsBase *)obj, &err);
11424 if (err) {
11425 goto out;
11426 }
11427 switch (obj->format) {
11428 case Q_CRYPTO_BLOCK_FORMAT_QCOW:
11429 visit_type_QCryptoBlockOptionsQCow_members(v, &obj->u.qcow, &err);
11430 break;
11431 case Q_CRYPTO_BLOCK_FORMAT_LUKS:
11432 visit_type_QCryptoBlockOptionsLUKS_members(v, &obj->u.luks, &err);
11433 break;
11434 default:
11435 abort();
11436 }
11437
11438out:
11439 error_propagate(errp, err);
11440}
11441
11442void visit_type_QCryptoBlockOpenOptions(Visitor *v, const char *name, QCryptoBlockOpenOptions **obj, Error **errp)
11443{
11444 Error *err = NULL;
11445
11446 visit_start_struct(v, name, (void **)obj, sizeof(QCryptoBlockOpenOptions), &err);
11447 if (err) {
11448 goto out;
11449 }
11450 if (!*obj) {
11451 goto out_obj;
11452 }
11453 visit_type_QCryptoBlockOpenOptions_members(v, *obj, &err);
11454 if (err) {
11455 goto out_obj;
11456 }
11457 visit_check_struct(v, &err);
11458out_obj:
11459 visit_end_struct(v, (void **)obj);
11460 if (err && visit_is_input(v)) {
11461 qapi_free_QCryptoBlockOpenOptions(*obj);
11462 *obj = NULL;
11463 }
11464out:
11465 error_propagate(errp, err);
11466}
11467
11468void visit_type_QCryptoBlockOptionsBase_members(Visitor *v, QCryptoBlockOptionsBase *obj, Error **errp)
11469{
11470 Error *err = NULL;
11471
11472 visit_type_QCryptoBlockFormat(v, "format", &obj->format, &err);
11473 if (err) {
11474 goto out;
11475 }
11476
11477out:
11478 error_propagate(errp, err);
11479}
11480
11481void visit_type_QCryptoBlockOptionsBase(Visitor *v, const char *name, QCryptoBlockOptionsBase **obj, Error **errp)
11482{
11483 Error *err = NULL;
11484
11485 visit_start_struct(v, name, (void **)obj, sizeof(QCryptoBlockOptionsBase), &err);
11486 if (err) {
11487 goto out;
11488 }
11489 if (!*obj) {
11490 goto out_obj;
11491 }
11492 visit_type_QCryptoBlockOptionsBase_members(v, *obj, &err);
11493 if (err) {
11494 goto out_obj;
11495 }
11496 visit_check_struct(v, &err);
11497out_obj:
11498 visit_end_struct(v, (void **)obj);
11499 if (err && visit_is_input(v)) {
11500 qapi_free_QCryptoBlockOptionsBase(*obj);
11501 *obj = NULL;
11502 }
11503out:
11504 error_propagate(errp, err);
11505}
11506
11507void visit_type_QCryptoBlockOptionsLUKS_members(Visitor *v, QCryptoBlockOptionsLUKS *obj, Error **errp)
11508{
11509 Error *err = NULL;
11510
11511 if (visit_optional(v, "key-secret", &obj->has_key_secret)) {
11512 visit_type_str(v, "key-secret", &obj->key_secret, &err);
11513 if (err) {
11514 goto out;
11515 }
11516 }
11517
11518out:
11519 error_propagate(errp, err);
11520}
11521
11522void visit_type_QCryptoBlockOptionsLUKS(Visitor *v, const char *name, QCryptoBlockOptionsLUKS **obj, Error **errp)
11523{
11524 Error *err = NULL;
11525
11526 visit_start_struct(v, name, (void **)obj, sizeof(QCryptoBlockOptionsLUKS), &err);
11527 if (err) {
11528 goto out;
11529 }
11530 if (!*obj) {
11531 goto out_obj;
11532 }
11533 visit_type_QCryptoBlockOptionsLUKS_members(v, *obj, &err);
11534 if (err) {
11535 goto out_obj;
11536 }
11537 visit_check_struct(v, &err);
11538out_obj:
11539 visit_end_struct(v, (void **)obj);
11540 if (err && visit_is_input(v)) {
11541 qapi_free_QCryptoBlockOptionsLUKS(*obj);
11542 *obj = NULL;
11543 }
11544out:
11545 error_propagate(errp, err);
11546}
11547
11548void visit_type_QCryptoBlockOptionsQCow_members(Visitor *v, QCryptoBlockOptionsQCow *obj, Error **errp)
11549{
11550 Error *err = NULL;
11551
11552 if (visit_optional(v, "key-secret", &obj->has_key_secret)) {
11553 visit_type_str(v, "key-secret", &obj->key_secret, &err);
11554 if (err) {
11555 goto out;
11556 }
11557 }
11558
11559out:
11560 error_propagate(errp, err);
11561}
11562
11563void visit_type_QCryptoBlockOptionsQCow(Visitor *v, const char *name, QCryptoBlockOptionsQCow **obj, Error **errp)
11564{
11565 Error *err = NULL;
11566
11567 visit_start_struct(v, name, (void **)obj, sizeof(QCryptoBlockOptionsQCow), &err);
11568 if (err) {
11569 goto out;
11570 }
11571 if (!*obj) {
11572 goto out_obj;
11573 }
11574 visit_type_QCryptoBlockOptionsQCow_members(v, *obj, &err);
11575 if (err) {
11576 goto out_obj;
11577 }
11578 visit_check_struct(v, &err);
11579out_obj:
11580 visit_end_struct(v, (void **)obj);
11581 if (err && visit_is_input(v)) {
11582 qapi_free_QCryptoBlockOptionsQCow(*obj);
11583 *obj = NULL;
11584 }
11585out:
11586 error_propagate(errp, err);
11587}
11588
11589void visit_type_QCryptoCipherAlgorithm(Visitor *v, const char *name, QCryptoCipherAlgorithm *obj, Error **errp)
11590{
11591 int value = *obj;
11592 visit_type_enum(v, name, &value, QCryptoCipherAlgorithm_lookup, errp);
11593 *obj = value;
11594}
11595
11596void visit_type_QCryptoCipherMode(Visitor *v, const char *name, QCryptoCipherMode *obj, Error **errp)
11597{
11598 int value = *obj;
11599 visit_type_enum(v, name, &value, QCryptoCipherMode_lookup, errp);
11600 *obj = value;
11601}
11602
11603void visit_type_QCryptoHashAlgorithm(Visitor *v, const char *name, QCryptoHashAlgorithm *obj, Error **errp)
11604{
11605 int value = *obj;
11606 visit_type_enum(v, name, &value, QCryptoHashAlgorithm_lookup, errp);
11607 *obj = value;
11608}
11609
11610void visit_type_QCryptoIVGenAlgorithm(Visitor *v, const char *name, QCryptoIVGenAlgorithm *obj, Error **errp)
11611{
11612 int value = *obj;
11613 visit_type_enum(v, name, &value, QCryptoIVGenAlgorithm_lookup, errp);
11614 *obj = value;
11615}
11616
11617void visit_type_QCryptoSecretFormat(Visitor *v, const char *name, QCryptoSecretFormat *obj, Error **errp)
11618{
11619 int value = *obj;
11620 visit_type_enum(v, name, &value, QCryptoSecretFormat_lookup, errp);
11621 *obj = value;
11622}
11623
11624void visit_type_QCryptoTLSCredsEndpoint(Visitor *v, const char *name, QCryptoTLSCredsEndpoint *obj, Error **errp)
11625{
11626 int value = *obj;
11627 visit_type_enum(v, name, &value, QCryptoTLSCredsEndpoint_lookup, errp);
11628 *obj = value;
11629}
11630
11631void visit_type_QKeyCode(Visitor *v, const char *name, QKeyCode *obj, Error **errp)
11632{
11633 int value = *obj;
11634 visit_type_enum(v, name, &value, QKeyCode_lookup, errp);
11635 *obj = value;
11636}
11637
11638void visit_type_QType(Visitor *v, const char *name, QType *obj, Error **errp)
11639{
11640 int value = *obj;
11641 visit_type_enum(v, name, &value, QType_lookup, errp);
11642 *obj = value;
11643}
11644
11645void visit_type_QapiErrorClass(Visitor *v, const char *name, QapiErrorClass *obj, Error **errp)
11646{
11647 int value = *obj;
11648 visit_type_enum(v, name, &value, QapiErrorClass_lookup, errp);
11649 *obj = value;
11650}
11651
11652void visit_type_Qcow2OverlapCheckFlags_members(Visitor *v, Qcow2OverlapCheckFlags *obj, Error **errp)
11653{
11654 Error *err = NULL;
11655
11656 if (visit_optional(v, "template", &obj->has_q_template)) {
11657 visit_type_Qcow2OverlapCheckMode(v, "template", &obj->q_template, &err);
11658 if (err) {
11659 goto out;
11660 }
11661 }
11662 if (visit_optional(v, "main-header", &obj->has_main_header)) {
11663 visit_type_bool(v, "main-header", &obj->main_header, &err);
11664 if (err) {
11665 goto out;
11666 }
11667 }
11668 if (visit_optional(v, "active-l1", &obj->has_active_l1)) {
11669 visit_type_bool(v, "active-l1", &obj->active_l1, &err);
11670 if (err) {
11671 goto out;
11672 }
11673 }
11674 if (visit_optional(v, "active-l2", &obj->has_active_l2)) {
11675 visit_type_bool(v, "active-l2", &obj->active_l2, &err);
11676 if (err) {
11677 goto out;
11678 }
11679 }
11680 if (visit_optional(v, "refcount-table", &obj->has_refcount_table)) {
11681 visit_type_bool(v, "refcount-table", &obj->refcount_table, &err);
11682 if (err) {
11683 goto out;
11684 }
11685 }
11686 if (visit_optional(v, "refcount-block", &obj->has_refcount_block)) {
11687 visit_type_bool(v, "refcount-block", &obj->refcount_block, &err);
11688 if (err) {
11689 goto out;
11690 }
11691 }
11692 if (visit_optional(v, "snapshot-table", &obj->has_snapshot_table)) {
11693 visit_type_bool(v, "snapshot-table", &obj->snapshot_table, &err);
11694 if (err) {
11695 goto out;
11696 }
11697 }
11698 if (visit_optional(v, "inactive-l1", &obj->has_inactive_l1)) {
11699 visit_type_bool(v, "inactive-l1", &obj->inactive_l1, &err);
11700 if (err) {
11701 goto out;
11702 }
11703 }
11704 if (visit_optional(v, "inactive-l2", &obj->has_inactive_l2)) {
11705 visit_type_bool(v, "inactive-l2", &obj->inactive_l2, &err);
11706 if (err) {
11707 goto out;
11708 }
11709 }
11710
11711out:
11712 error_propagate(errp, err);
11713}
11714
11715void visit_type_Qcow2OverlapCheckFlags(Visitor *v, const char *name, Qcow2OverlapCheckFlags **obj, Error **errp)
11716{
11717 Error *err = NULL;
11718
11719 visit_start_struct(v, name, (void **)obj, sizeof(Qcow2OverlapCheckFlags), &err);
11720 if (err) {
11721 goto out;
11722 }
11723 if (!*obj) {
11724 goto out_obj;
11725 }
11726 visit_type_Qcow2OverlapCheckFlags_members(v, *obj, &err);
11727 if (err) {
11728 goto out_obj;
11729 }
11730 visit_check_struct(v, &err);
11731out_obj:
11732 visit_end_struct(v, (void **)obj);
11733 if (err && visit_is_input(v)) {
11734 qapi_free_Qcow2OverlapCheckFlags(*obj);
11735 *obj = NULL;
11736 }
11737out:
11738 error_propagate(errp, err);
11739}
11740
11741void visit_type_Qcow2OverlapCheckMode(Visitor *v, const char *name, Qcow2OverlapCheckMode *obj, Error **errp)
11742{
11743 int value = *obj;
11744 visit_type_enum(v, name, &value, Qcow2OverlapCheckMode_lookup, errp);
11745 *obj = value;
11746}
11747
11748void visit_type_Qcow2OverlapChecks(Visitor *v, const char *name, Qcow2OverlapChecks **obj, Error **errp)
11749{
11750 Error *err = NULL;
11751
11752 visit_start_alternate(v, name, (GenericAlternate **)obj, sizeof(**obj),
11753 &err);
11754 if (err) {
11755 goto out;
11756 }
11757 if (!*obj) {
11758 goto out_obj;
11759 }
11760 switch ((*obj)->type) {
11761 case QTYPE_QDICT:
11762 visit_start_struct(v, name, NULL, 0, &err);
11763 if (err) {
11764 break;
11765 }
11766 visit_type_Qcow2OverlapCheckFlags_members(v, &(*obj)->u.flags, &err);
11767 if (!err) {
11768 visit_check_struct(v, &err);
11769 }
11770 visit_end_struct(v, NULL);
11771 break;
11772 case QTYPE_QSTRING:
11773 visit_type_Qcow2OverlapCheckMode(v, name, &(*obj)->u.mode, &err);
11774 break;
11775 case QTYPE_NONE:
11776 abort();
11777 default:
11778 error_setg(&err, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
11779 "Qcow2OverlapChecks");
11780 }
11781out_obj:
11782 visit_end_alternate(v, (void **)obj);
11783 if (err && visit_is_input(v)) {
11784 qapi_free_Qcow2OverlapChecks(*obj);
11785 *obj = NULL;
11786 }
11787out:
11788 error_propagate(errp, err);
11789}
11790
11791void visit_type_QuorumOpType(Visitor *v, const char *name, QuorumOpType *obj, Error **errp)
11792{
11793 int value = *obj;
11794 visit_type_enum(v, name, &value, QuorumOpType_lookup, errp);
11795 *obj = value;
11796}
11797
11798void visit_type_QuorumReadPattern(Visitor *v, const char *name, QuorumReadPattern *obj, Error **errp)
11799{
11800 int value = *obj;
11801 visit_type_enum(v, name, &value, QuorumReadPattern_lookup, errp);
11802 *obj = value;
11803}
11804
11805void visit_type_ReplayMode(Visitor *v, const char *name, ReplayMode *obj, Error **errp)
11806{
11807 int value = *obj;
11808 visit_type_enum(v, name, &value, ReplayMode_lookup, errp);
11809 *obj = value;
11810}
11811
11812void visit_type_ReplicationMode(Visitor *v, const char *name, ReplicationMode *obj, Error **errp)
11813{
11814 int value = *obj;
11815 visit_type_enum(v, name, &value, ReplicationMode_lookup, errp);
11816 *obj = value;
11817}
11818
11819void visit_type_ReplicationStatus_members(Visitor *v, ReplicationStatus *obj, Error **errp)
11820{
11821 Error *err = NULL;
11822
11823 visit_type_bool(v, "error", &obj->error, &err);
11824 if (err) {
11825 goto out;
11826 }
11827 if (visit_optional(v, "desc", &obj->has_desc)) {
11828 visit_type_str(v, "desc", &obj->desc, &err);
11829 if (err) {
11830 goto out;
11831 }
11832 }
11833
11834out:
11835 error_propagate(errp, err);
11836}
11837
11838void visit_type_ReplicationStatus(Visitor *v, const char *name, ReplicationStatus **obj, Error **errp)
11839{
11840 Error *err = NULL;
11841
11842 visit_start_struct(v, name, (void **)obj, sizeof(ReplicationStatus), &err);
11843 if (err) {
11844 goto out;
11845 }
11846 if (!*obj) {
11847 goto out_obj;
11848 }
11849 visit_type_ReplicationStatus_members(v, *obj, &err);
11850 if (err) {
11851 goto out_obj;
11852 }
11853 visit_check_struct(v, &err);
11854out_obj:
11855 visit_end_struct(v, (void **)obj);
11856 if (err && visit_is_input(v)) {
11857 qapi_free_ReplicationStatus(*obj);
11858 *obj = NULL;
11859 }
11860out:
11861 error_propagate(errp, err);
11862}
11863
11864void visit_type_RockerOfDpaFlow_members(Visitor *v, RockerOfDpaFlow *obj, Error **errp)
11865{
11866 Error *err = NULL;
11867
11868 visit_type_uint64(v, "cookie", &obj->cookie, &err);
11869 if (err) {
11870 goto out;
11871 }
11872 visit_type_uint64(v, "hits", &obj->hits, &err);
11873 if (err) {
11874 goto out;
11875 }
11876 visit_type_RockerOfDpaFlowKey(v, "key", &obj->key, &err);
11877 if (err) {
11878 goto out;
11879 }
11880 visit_type_RockerOfDpaFlowMask(v, "mask", &obj->mask, &err);
11881 if (err) {
11882 goto out;
11883 }
11884 visit_type_RockerOfDpaFlowAction(v, "action", &obj->action, &err);
11885 if (err) {
11886 goto out;
11887 }
11888
11889out:
11890 error_propagate(errp, err);
11891}
11892
11893void visit_type_RockerOfDpaFlow(Visitor *v, const char *name, RockerOfDpaFlow **obj, Error **errp)
11894{
11895 Error *err = NULL;
11896
11897 visit_start_struct(v, name, (void **)obj, sizeof(RockerOfDpaFlow), &err);
11898 if (err) {
11899 goto out;
11900 }
11901 if (!*obj) {
11902 goto out_obj;
11903 }
11904 visit_type_RockerOfDpaFlow_members(v, *obj, &err);
11905 if (err) {
11906 goto out_obj;
11907 }
11908 visit_check_struct(v, &err);
11909out_obj:
11910 visit_end_struct(v, (void **)obj);
11911 if (err && visit_is_input(v)) {
11912 qapi_free_RockerOfDpaFlow(*obj);
11913 *obj = NULL;
11914 }
11915out:
11916 error_propagate(errp, err);
11917}
11918
11919void visit_type_RockerOfDpaFlowAction_members(Visitor *v, RockerOfDpaFlowAction *obj, Error **errp)
11920{
11921 Error *err = NULL;
11922
11923 if (visit_optional(v, "goto-tbl", &obj->has_goto_tbl)) {
11924 visit_type_uint32(v, "goto-tbl", &obj->goto_tbl, &err);
11925 if (err) {
11926 goto out;
11927 }
11928 }
11929 if (visit_optional(v, "group-id", &obj->has_group_id)) {
11930 visit_type_uint32(v, "group-id", &obj->group_id, &err);
11931 if (err) {
11932 goto out;
11933 }
11934 }
11935 if (visit_optional(v, "tunnel-lport", &obj->has_tunnel_lport)) {
11936 visit_type_uint32(v, "tunnel-lport", &obj->tunnel_lport, &err);
11937 if (err) {
11938 goto out;
11939 }
11940 }
11941 if (visit_optional(v, "vlan-id", &obj->has_vlan_id)) {
11942 visit_type_uint16(v, "vlan-id", &obj->vlan_id, &err);
11943 if (err) {
11944 goto out;
11945 }
11946 }
11947 if (visit_optional(v, "new-vlan-id", &obj->has_new_vlan_id)) {
11948 visit_type_uint16(v, "new-vlan-id", &obj->new_vlan_id, &err);
11949 if (err) {
11950 goto out;
11951 }
11952 }
11953 if (visit_optional(v, "out-pport", &obj->has_out_pport)) {
11954 visit_type_uint32(v, "out-pport", &obj->out_pport, &err);
11955 if (err) {
11956 goto out;
11957 }
11958 }
11959
11960out:
11961 error_propagate(errp, err);
11962}
11963
11964void visit_type_RockerOfDpaFlowAction(Visitor *v, const char *name, RockerOfDpaFlowAction **obj, Error **errp)
11965{
11966 Error *err = NULL;
11967
11968 visit_start_struct(v, name, (void **)obj, sizeof(RockerOfDpaFlowAction), &err);
11969 if (err) {
11970 goto out;
11971 }
11972 if (!*obj) {
11973 goto out_obj;
11974 }
11975 visit_type_RockerOfDpaFlowAction_members(v, *obj, &err);
11976 if (err) {
11977 goto out_obj;
11978 }
11979 visit_check_struct(v, &err);
11980out_obj:
11981 visit_end_struct(v, (void **)obj);
11982 if (err && visit_is_input(v)) {
11983 qapi_free_RockerOfDpaFlowAction(*obj);
11984 *obj = NULL;
11985 }
11986out:
11987 error_propagate(errp, err);
11988}
11989
11990void visit_type_RockerOfDpaFlowKey_members(Visitor *v, RockerOfDpaFlowKey *obj, Error **errp)
11991{
11992 Error *err = NULL;
11993
11994 visit_type_uint32(v, "priority", &obj->priority, &err);
11995 if (err) {
11996 goto out;
11997 }
11998 visit_type_uint32(v, "tbl-id", &obj->tbl_id, &err);
11999 if (err) {
12000 goto out;
12001 }
12002 if (visit_optional(v, "in-pport", &obj->has_in_pport)) {
12003 visit_type_uint32(v, "in-pport", &obj->in_pport, &err);
12004 if (err) {
12005 goto out;
12006 }
12007 }
12008 if (visit_optional(v, "tunnel-id", &obj->has_tunnel_id)) {
12009 visit_type_uint32(v, "tunnel-id", &obj->tunnel_id, &err);
12010 if (err) {
12011 goto out;
12012 }
12013 }
12014 if (visit_optional(v, "vlan-id", &obj->has_vlan_id)) {
12015 visit_type_uint16(v, "vlan-id", &obj->vlan_id, &err);
12016 if (err) {
12017 goto out;
12018 }
12019 }
12020 if (visit_optional(v, "eth-type", &obj->has_eth_type)) {
12021 visit_type_uint16(v, "eth-type", &obj->eth_type, &err);
12022 if (err) {
12023 goto out;
12024 }
12025 }
12026 if (visit_optional(v, "eth-src", &obj->has_eth_src)) {
12027 visit_type_str(v, "eth-src", &obj->eth_src, &err);
12028 if (err) {
12029 goto out;
12030 }
12031 }
12032 if (visit_optional(v, "eth-dst", &obj->has_eth_dst)) {
12033 visit_type_str(v, "eth-dst", &obj->eth_dst, &err);
12034 if (err) {
12035 goto out;
12036 }
12037 }
12038 if (visit_optional(v, "ip-proto", &obj->has_ip_proto)) {
12039 visit_type_uint8(v, "ip-proto", &obj->ip_proto, &err);
12040 if (err) {
12041 goto out;
12042 }
12043 }
12044 if (visit_optional(v, "ip-tos", &obj->has_ip_tos)) {
12045 visit_type_uint8(v, "ip-tos", &obj->ip_tos, &err);
12046 if (err) {
12047 goto out;
12048 }
12049 }
12050 if (visit_optional(v, "ip-dst", &obj->has_ip_dst)) {
12051 visit_type_str(v, "ip-dst", &obj->ip_dst, &err);
12052 if (err) {
12053 goto out;
12054 }
12055 }
12056
12057out:
12058 error_propagate(errp, err);
12059}
12060
12061void visit_type_RockerOfDpaFlowKey(Visitor *v, const char *name, RockerOfDpaFlowKey **obj, Error **errp)
12062{
12063 Error *err = NULL;
12064
12065 visit_start_struct(v, name, (void **)obj, sizeof(RockerOfDpaFlowKey), &err);
12066 if (err) {
12067 goto out;
12068 }
12069 if (!*obj) {
12070 goto out_obj;
12071 }
12072 visit_type_RockerOfDpaFlowKey_members(v, *obj, &err);
12073 if (err) {
12074 goto out_obj;
12075 }
12076 visit_check_struct(v, &err);
12077out_obj:
12078 visit_end_struct(v, (void **)obj);
12079 if (err && visit_is_input(v)) {
12080 qapi_free_RockerOfDpaFlowKey(*obj);
12081 *obj = NULL;
12082 }
12083out:
12084 error_propagate(errp, err);
12085}
12086
12087void visit_type_RockerOfDpaFlowList(Visitor *v, const char *name, RockerOfDpaFlowList **obj, Error **errp)
12088{
12089 Error *err = NULL;
12090 RockerOfDpaFlowList *tail;
12091 size_t size = sizeof(**obj);
12092
12093 visit_start_list(v, name, (GenericList **)obj, size, &err);
12094 if (err) {
12095 goto out;
12096 }
12097
12098 for (tail = *obj; tail;
12099 tail = (RockerOfDpaFlowList *)visit_next_list(v, (GenericList *)tail, size)) {
12100 visit_type_RockerOfDpaFlow(v, NULL, &tail->value, &err);
12101 if (err) {
12102 break;
12103 }
12104 }
12105
12106 if (!err) {
12107 visit_check_list(v, &err);
12108 }
12109 visit_end_list(v, (void **)obj);
12110 if (err && visit_is_input(v)) {
12111 qapi_free_RockerOfDpaFlowList(*obj);
12112 *obj = NULL;
12113 }
12114out:
12115 error_propagate(errp, err);
12116}
12117
12118void visit_type_RockerOfDpaFlowMask_members(Visitor *v, RockerOfDpaFlowMask *obj, Error **errp)
12119{
12120 Error *err = NULL;
12121
12122 if (visit_optional(v, "in-pport", &obj->has_in_pport)) {
12123 visit_type_uint32(v, "in-pport", &obj->in_pport, &err);
12124 if (err) {
12125 goto out;
12126 }
12127 }
12128 if (visit_optional(v, "tunnel-id", &obj->has_tunnel_id)) {
12129 visit_type_uint32(v, "tunnel-id", &obj->tunnel_id, &err);
12130 if (err) {
12131 goto out;
12132 }
12133 }
12134 if (visit_optional(v, "vlan-id", &obj->has_vlan_id)) {
12135 visit_type_uint16(v, "vlan-id", &obj->vlan_id, &err);
12136 if (err) {
12137 goto out;
12138 }
12139 }
12140 if (visit_optional(v, "eth-src", &obj->has_eth_src)) {
12141 visit_type_str(v, "eth-src", &obj->eth_src, &err);
12142 if (err) {
12143 goto out;
12144 }
12145 }
12146 if (visit_optional(v, "eth-dst", &obj->has_eth_dst)) {
12147 visit_type_str(v, "eth-dst", &obj->eth_dst, &err);
12148 if (err) {
12149 goto out;
12150 }
12151 }
12152 if (visit_optional(v, "ip-proto", &obj->has_ip_proto)) {
12153 visit_type_uint8(v, "ip-proto", &obj->ip_proto, &err);
12154 if (err) {
12155 goto out;
12156 }
12157 }
12158 if (visit_optional(v, "ip-tos", &obj->has_ip_tos)) {
12159 visit_type_uint8(v, "ip-tos", &obj->ip_tos, &err);
12160 if (err) {
12161 goto out;
12162 }
12163 }
12164
12165out:
12166 error_propagate(errp, err);
12167}
12168
12169void visit_type_RockerOfDpaFlowMask(Visitor *v, const char *name, RockerOfDpaFlowMask **obj, Error **errp)
12170{
12171 Error *err = NULL;
12172
12173 visit_start_struct(v, name, (void **)obj, sizeof(RockerOfDpaFlowMask), &err);
12174 if (err) {
12175 goto out;
12176 }
12177 if (!*obj) {
12178 goto out_obj;
12179 }
12180 visit_type_RockerOfDpaFlowMask_members(v, *obj, &err);
12181 if (err) {
12182 goto out_obj;
12183 }
12184 visit_check_struct(v, &err);
12185out_obj:
12186 visit_end_struct(v, (void **)obj);
12187 if (err && visit_is_input(v)) {
12188 qapi_free_RockerOfDpaFlowMask(*obj);
12189 *obj = NULL;
12190 }
12191out:
12192 error_propagate(errp, err);
12193}
12194
12195void visit_type_RockerOfDpaGroup_members(Visitor *v, RockerOfDpaGroup *obj, Error **errp)
12196{
12197 Error *err = NULL;
12198
12199 visit_type_uint32(v, "id", &obj->id, &err);
12200 if (err) {
12201 goto out;
12202 }
12203 visit_type_uint8(v, "type", &obj->type, &err);
12204 if (err) {
12205 goto out;
12206 }
12207 if (visit_optional(v, "vlan-id", &obj->has_vlan_id)) {
12208 visit_type_uint16(v, "vlan-id", &obj->vlan_id, &err);
12209 if (err) {
12210 goto out;
12211 }
12212 }
12213 if (visit_optional(v, "pport", &obj->has_pport)) {
12214 visit_type_uint32(v, "pport", &obj->pport, &err);
12215 if (err) {
12216 goto out;
12217 }
12218 }
12219 if (visit_optional(v, "index", &obj->has_index)) {
12220 visit_type_uint32(v, "index", &obj->index, &err);
12221 if (err) {
12222 goto out;
12223 }
12224 }
12225 if (visit_optional(v, "out-pport", &obj->has_out_pport)) {
12226 visit_type_uint32(v, "out-pport", &obj->out_pport, &err);
12227 if (err) {
12228 goto out;
12229 }
12230 }
12231 if (visit_optional(v, "group-id", &obj->has_group_id)) {
12232 visit_type_uint32(v, "group-id", &obj->group_id, &err);
12233 if (err) {
12234 goto out;
12235 }
12236 }
12237 if (visit_optional(v, "set-vlan-id", &obj->has_set_vlan_id)) {
12238 visit_type_uint16(v, "set-vlan-id", &obj->set_vlan_id, &err);
12239 if (err) {
12240 goto out;
12241 }
12242 }
12243 if (visit_optional(v, "pop-vlan", &obj->has_pop_vlan)) {
12244 visit_type_uint8(v, "pop-vlan", &obj->pop_vlan, &err);
12245 if (err) {
12246 goto out;
12247 }
12248 }
12249 if (visit_optional(v, "group-ids", &obj->has_group_ids)) {
12250 visit_type_uint32List(v, "group-ids", &obj->group_ids, &err);
12251 if (err) {
12252 goto out;
12253 }
12254 }
12255 if (visit_optional(v, "set-eth-src", &obj->has_set_eth_src)) {
12256 visit_type_str(v, "set-eth-src", &obj->set_eth_src, &err);
12257 if (err) {
12258 goto out;
12259 }
12260 }
12261 if (visit_optional(v, "set-eth-dst", &obj->has_set_eth_dst)) {
12262 visit_type_str(v, "set-eth-dst", &obj->set_eth_dst, &err);
12263 if (err) {
12264 goto out;
12265 }
12266 }
12267 if (visit_optional(v, "ttl-check", &obj->has_ttl_check)) {
12268 visit_type_uint8(v, "ttl-check", &obj->ttl_check, &err);
12269 if (err) {
12270 goto out;
12271 }
12272 }
12273
12274out:
12275 error_propagate(errp, err);
12276}
12277
12278void visit_type_RockerOfDpaGroup(Visitor *v, const char *name, RockerOfDpaGroup **obj, Error **errp)
12279{
12280 Error *err = NULL;
12281
12282 visit_start_struct(v, name, (void **)obj, sizeof(RockerOfDpaGroup), &err);
12283 if (err) {
12284 goto out;
12285 }
12286 if (!*obj) {
12287 goto out_obj;
12288 }
12289 visit_type_RockerOfDpaGroup_members(v, *obj, &err);
12290 if (err) {
12291 goto out_obj;
12292 }
12293 visit_check_struct(v, &err);
12294out_obj:
12295 visit_end_struct(v, (void **)obj);
12296 if (err && visit_is_input(v)) {
12297 qapi_free_RockerOfDpaGroup(*obj);
12298 *obj = NULL;
12299 }
12300out:
12301 error_propagate(errp, err);
12302}
12303
12304void visit_type_RockerOfDpaGroupList(Visitor *v, const char *name, RockerOfDpaGroupList **obj, Error **errp)
12305{
12306 Error *err = NULL;
12307 RockerOfDpaGroupList *tail;
12308 size_t size = sizeof(**obj);
12309
12310 visit_start_list(v, name, (GenericList **)obj, size, &err);
12311 if (err) {
12312 goto out;
12313 }
12314
12315 for (tail = *obj; tail;
12316 tail = (RockerOfDpaGroupList *)visit_next_list(v, (GenericList *)tail, size)) {
12317 visit_type_RockerOfDpaGroup(v, NULL, &tail->value, &err);
12318 if (err) {
12319 break;
12320 }
12321 }
12322
12323 if (!err) {
12324 visit_check_list(v, &err);
12325 }
12326 visit_end_list(v, (void **)obj);
12327 if (err && visit_is_input(v)) {
12328 qapi_free_RockerOfDpaGroupList(*obj);
12329 *obj = NULL;
12330 }
12331out:
12332 error_propagate(errp, err);
12333}
12334
12335void visit_type_RockerPort_members(Visitor *v, RockerPort *obj, Error **errp)
12336{
12337 Error *err = NULL;
12338
12339 visit_type_str(v, "name", &obj->name, &err);
12340 if (err) {
12341 goto out;
12342 }
12343 visit_type_bool(v, "enabled", &obj->enabled, &err);
12344 if (err) {
12345 goto out;
12346 }
12347 visit_type_bool(v, "link-up", &obj->link_up, &err);
12348 if (err) {
12349 goto out;
12350 }
12351 visit_type_uint32(v, "speed", &obj->speed, &err);
12352 if (err) {
12353 goto out;
12354 }
12355 visit_type_RockerPortDuplex(v, "duplex", &obj->duplex, &err);
12356 if (err) {
12357 goto out;
12358 }
12359 visit_type_RockerPortAutoneg(v, "autoneg", &obj->autoneg, &err);
12360 if (err) {
12361 goto out;
12362 }
12363
12364out:
12365 error_propagate(errp, err);
12366}
12367
12368void visit_type_RockerPort(Visitor *v, const char *name, RockerPort **obj, Error **errp)
12369{
12370 Error *err = NULL;
12371
12372 visit_start_struct(v, name, (void **)obj, sizeof(RockerPort), &err);
12373 if (err) {
12374 goto out;
12375 }
12376 if (!*obj) {
12377 goto out_obj;
12378 }
12379 visit_type_RockerPort_members(v, *obj, &err);
12380 if (err) {
12381 goto out_obj;
12382 }
12383 visit_check_struct(v, &err);
12384out_obj:
12385 visit_end_struct(v, (void **)obj);
12386 if (err && visit_is_input(v)) {
12387 qapi_free_RockerPort(*obj);
12388 *obj = NULL;
12389 }
12390out:
12391 error_propagate(errp, err);
12392}
12393
12394void visit_type_RockerPortAutoneg(Visitor *v, const char *name, RockerPortAutoneg *obj, Error **errp)
12395{
12396 int value = *obj;
12397 visit_type_enum(v, name, &value, RockerPortAutoneg_lookup, errp);
12398 *obj = value;
12399}
12400
12401void visit_type_RockerPortDuplex(Visitor *v, const char *name, RockerPortDuplex *obj, Error **errp)
12402{
12403 int value = *obj;
12404 visit_type_enum(v, name, &value, RockerPortDuplex_lookup, errp);
12405 *obj = value;
12406}
12407
12408void visit_type_RockerPortList(Visitor *v, const char *name, RockerPortList **obj, Error **errp)
12409{
12410 Error *err = NULL;
12411 RockerPortList *tail;
12412 size_t size = sizeof(**obj);
12413
12414 visit_start_list(v, name, (GenericList **)obj, size, &err);
12415 if (err) {
12416 goto out;
12417 }
12418
12419 for (tail = *obj; tail;
12420 tail = (RockerPortList *)visit_next_list(v, (GenericList *)tail, size)) {
12421 visit_type_RockerPort(v, NULL, &tail->value, &err);
12422 if (err) {
12423 break;
12424 }
12425 }
12426
12427 if (!err) {
12428 visit_check_list(v, &err);
12429 }
12430 visit_end_list(v, (void **)obj);
12431 if (err && visit_is_input(v)) {
12432 qapi_free_RockerPortList(*obj);
12433 *obj = NULL;
12434 }
12435out:
12436 error_propagate(errp, err);
12437}
12438
12439void visit_type_RockerSwitch_members(Visitor *v, RockerSwitch *obj, Error **errp)
12440{
12441 Error *err = NULL;
12442
12443 visit_type_str(v, "name", &obj->name, &err);
12444 if (err) {
12445 goto out;
12446 }
12447 visit_type_uint64(v, "id", &obj->id, &err);
12448 if (err) {
12449 goto out;
12450 }
12451 visit_type_uint32(v, "ports", &obj->ports, &err);
12452 if (err) {
12453 goto out;
12454 }
12455
12456out:
12457 error_propagate(errp, err);
12458}
12459
12460void visit_type_RockerSwitch(Visitor *v, const char *name, RockerSwitch **obj, Error **errp)
12461{
12462 Error *err = NULL;
12463
12464 visit_start_struct(v, name, (void **)obj, sizeof(RockerSwitch), &err);
12465 if (err) {
12466 goto out;
12467 }
12468 if (!*obj) {
12469 goto out_obj;
12470 }
12471 visit_type_RockerSwitch_members(v, *obj, &err);
12472 if (err) {
12473 goto out_obj;
12474 }
12475 visit_check_struct(v, &err);
12476out_obj:
12477 visit_end_struct(v, (void **)obj);
12478 if (err && visit_is_input(v)) {
12479 qapi_free_RockerSwitch(*obj);
12480 *obj = NULL;
12481 }
12482out:
12483 error_propagate(errp, err);
12484}
12485
12486void visit_type_RunState(Visitor *v, const char *name, RunState *obj, Error **errp)
12487{
12488 int value = *obj;
12489 visit_type_enum(v, name, &value, RunState_lookup, errp);
12490 *obj = value;
12491}
12492
12493void visit_type_RxFilterInfo_members(Visitor *v, RxFilterInfo *obj, Error **errp)
12494{
12495 Error *err = NULL;
12496
12497 visit_type_str(v, "name", &obj->name, &err);
12498 if (err) {
12499 goto out;
12500 }
12501 visit_type_bool(v, "promiscuous", &obj->promiscuous, &err);
12502 if (err) {
12503 goto out;
12504 }
12505 visit_type_RxState(v, "multicast", &obj->multicast, &err);
12506 if (err) {
12507 goto out;
12508 }
12509 visit_type_RxState(v, "unicast", &obj->unicast, &err);
12510 if (err) {
12511 goto out;
12512 }
12513 visit_type_RxState(v, "vlan", &obj->vlan, &err);
12514 if (err) {
12515 goto out;
12516 }
12517 visit_type_bool(v, "broadcast-allowed", &obj->broadcast_allowed, &err);
12518 if (err) {
12519 goto out;
12520 }
12521 visit_type_bool(v, "multicast-overflow", &obj->multicast_overflow, &err);
12522 if (err) {
12523 goto out;
12524 }
12525 visit_type_bool(v, "unicast-overflow", &obj->unicast_overflow, &err);
12526 if (err) {
12527 goto out;
12528 }
12529 visit_type_str(v, "main-mac", &obj->main_mac, &err);
12530 if (err) {
12531 goto out;
12532 }
12533 visit_type_intList(v, "vlan-table", &obj->vlan_table, &err);
12534 if (err) {
12535 goto out;
12536 }
12537 visit_type_strList(v, "unicast-table", &obj->unicast_table, &err);
12538 if (err) {
12539 goto out;
12540 }
12541 visit_type_strList(v, "multicast-table", &obj->multicast_table, &err);
12542 if (err) {
12543 goto out;
12544 }
12545
12546out:
12547 error_propagate(errp, err);
12548}
12549
12550void visit_type_RxFilterInfo(Visitor *v, const char *name, RxFilterInfo **obj, Error **errp)
12551{
12552 Error *err = NULL;
12553
12554 visit_start_struct(v, name, (void **)obj, sizeof(RxFilterInfo), &err);
12555 if (err) {
12556 goto out;
12557 }
12558 if (!*obj) {
12559 goto out_obj;
12560 }
12561 visit_type_RxFilterInfo_members(v, *obj, &err);
12562 if (err) {
12563 goto out_obj;
12564 }
12565 visit_check_struct(v, &err);
12566out_obj:
12567 visit_end_struct(v, (void **)obj);
12568 if (err && visit_is_input(v)) {
12569 qapi_free_RxFilterInfo(*obj);
12570 *obj = NULL;
12571 }
12572out:
12573 error_propagate(errp, err);
12574}
12575
12576void visit_type_RxFilterInfoList(Visitor *v, const char *name, RxFilterInfoList **obj, Error **errp)
12577{
12578 Error *err = NULL;
12579 RxFilterInfoList *tail;
12580 size_t size = sizeof(**obj);
12581
12582 visit_start_list(v, name, (GenericList **)obj, size, &err);
12583 if (err) {
12584 goto out;
12585 }
12586
12587 for (tail = *obj; tail;
12588 tail = (RxFilterInfoList *)visit_next_list(v, (GenericList *)tail, size)) {
12589 visit_type_RxFilterInfo(v, NULL, &tail->value, &err);
12590 if (err) {
12591 break;
12592 }
12593 }
12594
12595 if (!err) {
12596 visit_check_list(v, &err);
12597 }
12598 visit_end_list(v, (void **)obj);
12599 if (err && visit_is_input(v)) {
12600 qapi_free_RxFilterInfoList(*obj);
12601 *obj = NULL;
12602 }
12603out:
12604 error_propagate(errp, err);
12605}
12606
12607void visit_type_RxState(Visitor *v, const char *name, RxState *obj, Error **errp)
12608{
12609 int value = *obj;
12610 visit_type_enum(v, name, &value, RxState_lookup, errp);
12611 *obj = value;
12612}
12613
12614void visit_type_SchemaInfo_members(Visitor *v, SchemaInfo *obj, Error **errp)
12615{
12616 Error *err = NULL;
12617
12618 visit_type_q_obj_SchemaInfo_base_members(v, (q_obj_SchemaInfo_base *)obj, &err);
12619 if (err) {
12620 goto out;
12621 }
12622 switch (obj->meta_type) {
12623 case SCHEMA_META_TYPE_BUILTIN:
12624 visit_type_SchemaInfoBuiltin_members(v, &obj->u.builtin, &err);
12625 break;
12626 case SCHEMA_META_TYPE_ENUM:
12627 visit_type_SchemaInfoEnum_members(v, &obj->u.q_enum, &err);
12628 break;
12629 case SCHEMA_META_TYPE_ARRAY:
12630 visit_type_SchemaInfoArray_members(v, &obj->u.array, &err);
12631 break;
12632 case SCHEMA_META_TYPE_OBJECT:
12633 visit_type_SchemaInfoObject_members(v, &obj->u.object, &err);
12634 break;
12635 case SCHEMA_META_TYPE_ALTERNATE:
12636 visit_type_SchemaInfoAlternate_members(v, &obj->u.alternate, &err);
12637 break;
12638 case SCHEMA_META_TYPE_COMMAND:
12639 visit_type_SchemaInfoCommand_members(v, &obj->u.command, &err);
12640 break;
12641 case SCHEMA_META_TYPE_EVENT:
12642 visit_type_SchemaInfoEvent_members(v, &obj->u.event, &err);
12643 break;
12644 default:
12645 abort();
12646 }
12647
12648out:
12649 error_propagate(errp, err);
12650}
12651
12652void visit_type_SchemaInfo(Visitor *v, const char *name, SchemaInfo **obj, Error **errp)
12653{
12654 Error *err = NULL;
12655
12656 visit_start_struct(v, name, (void **)obj, sizeof(SchemaInfo), &err);
12657 if (err) {
12658 goto out;
12659 }
12660 if (!*obj) {
12661 goto out_obj;
12662 }
12663 visit_type_SchemaInfo_members(v, *obj, &err);
12664 if (err) {
12665 goto out_obj;
12666 }
12667 visit_check_struct(v, &err);
12668out_obj:
12669 visit_end_struct(v, (void **)obj);
12670 if (err && visit_is_input(v)) {
12671 qapi_free_SchemaInfo(*obj);
12672 *obj = NULL;
12673 }
12674out:
12675 error_propagate(errp, err);
12676}
12677
12678void visit_type_SchemaInfoAlternate_members(Visitor *v, SchemaInfoAlternate *obj, Error **errp)
12679{
12680 Error *err = NULL;
12681
12682 visit_type_SchemaInfoAlternateMemberList(v, "members", &obj->members, &err);
12683 if (err) {
12684 goto out;
12685 }
12686
12687out:
12688 error_propagate(errp, err);
12689}
12690
12691void visit_type_SchemaInfoAlternate(Visitor *v, const char *name, SchemaInfoAlternate **obj, Error **errp)
12692{
12693 Error *err = NULL;
12694
12695 visit_start_struct(v, name, (void **)obj, sizeof(SchemaInfoAlternate), &err);
12696 if (err) {
12697 goto out;
12698 }
12699 if (!*obj) {
12700 goto out_obj;
12701 }
12702 visit_type_SchemaInfoAlternate_members(v, *obj, &err);
12703 if (err) {
12704 goto out_obj;
12705 }
12706 visit_check_struct(v, &err);
12707out_obj:
12708 visit_end_struct(v, (void **)obj);
12709 if (err && visit_is_input(v)) {
12710 qapi_free_SchemaInfoAlternate(*obj);
12711 *obj = NULL;
12712 }
12713out:
12714 error_propagate(errp, err);
12715}
12716
12717void visit_type_SchemaInfoAlternateMember_members(Visitor *v, SchemaInfoAlternateMember *obj, Error **errp)
12718{
12719 Error *err = NULL;
12720
12721 visit_type_str(v, "type", &obj->type, &err);
12722 if (err) {
12723 goto out;
12724 }
12725
12726out:
12727 error_propagate(errp, err);
12728}
12729
12730void visit_type_SchemaInfoAlternateMember(Visitor *v, const char *name, SchemaInfoAlternateMember **obj, Error **errp)
12731{
12732 Error *err = NULL;
12733
12734 visit_start_struct(v, name, (void **)obj, sizeof(SchemaInfoAlternateMember), &err);
12735 if (err) {
12736 goto out;
12737 }
12738 if (!*obj) {
12739 goto out_obj;
12740 }
12741 visit_type_SchemaInfoAlternateMember_members(v, *obj, &err);
12742 if (err) {
12743 goto out_obj;
12744 }
12745 visit_check_struct(v, &err);
12746out_obj:
12747 visit_end_struct(v, (void **)obj);
12748 if (err && visit_is_input(v)) {
12749 qapi_free_SchemaInfoAlternateMember(*obj);
12750 *obj = NULL;
12751 }
12752out:
12753 error_propagate(errp, err);
12754}
12755
12756void visit_type_SchemaInfoAlternateMemberList(Visitor *v, const char *name, SchemaInfoAlternateMemberList **obj, Error **errp)
12757{
12758 Error *err = NULL;
12759 SchemaInfoAlternateMemberList *tail;
12760 size_t size = sizeof(**obj);
12761
12762 visit_start_list(v, name, (GenericList **)obj, size, &err);
12763 if (err) {
12764 goto out;
12765 }
12766
12767 for (tail = *obj; tail;
12768 tail = (SchemaInfoAlternateMemberList *)visit_next_list(v, (GenericList *)tail, size)) {
12769 visit_type_SchemaInfoAlternateMember(v, NULL, &tail->value, &err);
12770 if (err) {
12771 break;
12772 }
12773 }
12774
12775 if (!err) {
12776 visit_check_list(v, &err);
12777 }
12778 visit_end_list(v, (void **)obj);
12779 if (err && visit_is_input(v)) {
12780 qapi_free_SchemaInfoAlternateMemberList(*obj);
12781 *obj = NULL;
12782 }
12783out:
12784 error_propagate(errp, err);
12785}
12786
12787void visit_type_SchemaInfoArray_members(Visitor *v, SchemaInfoArray *obj, Error **errp)
12788{
12789 Error *err = NULL;
12790
12791 visit_type_str(v, "element-type", &obj->element_type, &err);
12792 if (err) {
12793 goto out;
12794 }
12795
12796out:
12797 error_propagate(errp, err);
12798}
12799
12800void visit_type_SchemaInfoArray(Visitor *v, const char *name, SchemaInfoArray **obj, Error **errp)
12801{
12802 Error *err = NULL;
12803
12804 visit_start_struct(v, name, (void **)obj, sizeof(SchemaInfoArray), &err);
12805 if (err) {
12806 goto out;
12807 }
12808 if (!*obj) {
12809 goto out_obj;
12810 }
12811 visit_type_SchemaInfoArray_members(v, *obj, &err);
12812 if (err) {
12813 goto out_obj;
12814 }
12815 visit_check_struct(v, &err);
12816out_obj:
12817 visit_end_struct(v, (void **)obj);
12818 if (err && visit_is_input(v)) {
12819 qapi_free_SchemaInfoArray(*obj);
12820 *obj = NULL;
12821 }
12822out:
12823 error_propagate(errp, err);
12824}
12825
12826void visit_type_SchemaInfoBuiltin_members(Visitor *v, SchemaInfoBuiltin *obj, Error **errp)
12827{
12828 Error *err = NULL;
12829
12830 visit_type_JSONType(v, "json-type", &obj->json_type, &err);
12831 if (err) {
12832 goto out;
12833 }
12834
12835out:
12836 error_propagate(errp, err);
12837}
12838
12839void visit_type_SchemaInfoBuiltin(Visitor *v, const char *name, SchemaInfoBuiltin **obj, Error **errp)
12840{
12841 Error *err = NULL;
12842
12843 visit_start_struct(v, name, (void **)obj, sizeof(SchemaInfoBuiltin), &err);
12844 if (err) {
12845 goto out;
12846 }
12847 if (!*obj) {
12848 goto out_obj;
12849 }
12850 visit_type_SchemaInfoBuiltin_members(v, *obj, &err);
12851 if (err) {
12852 goto out_obj;
12853 }
12854 visit_check_struct(v, &err);
12855out_obj:
12856 visit_end_struct(v, (void **)obj);
12857 if (err && visit_is_input(v)) {
12858 qapi_free_SchemaInfoBuiltin(*obj);
12859 *obj = NULL;
12860 }
12861out:
12862 error_propagate(errp, err);
12863}
12864
12865void visit_type_SchemaInfoCommand_members(Visitor *v, SchemaInfoCommand *obj, Error **errp)
12866{
12867 Error *err = NULL;
12868
12869 visit_type_str(v, "arg-type", &obj->arg_type, &err);
12870 if (err) {
12871 goto out;
12872 }
12873 visit_type_str(v, "ret-type", &obj->ret_type, &err);
12874 if (err) {
12875 goto out;
12876 }
12877
12878out:
12879 error_propagate(errp, err);
12880}
12881
12882void visit_type_SchemaInfoCommand(Visitor *v, const char *name, SchemaInfoCommand **obj, Error **errp)
12883{
12884 Error *err = NULL;
12885
12886 visit_start_struct(v, name, (void **)obj, sizeof(SchemaInfoCommand), &err);
12887 if (err) {
12888 goto out;
12889 }
12890 if (!*obj) {
12891 goto out_obj;
12892 }
12893 visit_type_SchemaInfoCommand_members(v, *obj, &err);
12894 if (err) {
12895 goto out_obj;
12896 }
12897 visit_check_struct(v, &err);
12898out_obj:
12899 visit_end_struct(v, (void **)obj);
12900 if (err && visit_is_input(v)) {
12901 qapi_free_SchemaInfoCommand(*obj);
12902 *obj = NULL;
12903 }
12904out:
12905 error_propagate(errp, err);
12906}
12907
12908void visit_type_SchemaInfoEnum_members(Visitor *v, SchemaInfoEnum *obj, Error **errp)
12909{
12910 Error *err = NULL;
12911
12912 visit_type_strList(v, "values", &obj->values, &err);
12913 if (err) {
12914 goto out;
12915 }
12916
12917out:
12918 error_propagate(errp, err);
12919}
12920
12921void visit_type_SchemaInfoEnum(Visitor *v, const char *name, SchemaInfoEnum **obj, Error **errp)
12922{
12923 Error *err = NULL;
12924
12925 visit_start_struct(v, name, (void **)obj, sizeof(SchemaInfoEnum), &err);
12926 if (err) {
12927 goto out;
12928 }
12929 if (!*obj) {
12930 goto out_obj;
12931 }
12932 visit_type_SchemaInfoEnum_members(v, *obj, &err);
12933 if (err) {
12934 goto out_obj;
12935 }
12936 visit_check_struct(v, &err);
12937out_obj:
12938 visit_end_struct(v, (void **)obj);
12939 if (err && visit_is_input(v)) {
12940 qapi_free_SchemaInfoEnum(*obj);
12941 *obj = NULL;
12942 }
12943out:
12944 error_propagate(errp, err);
12945}
12946
12947void visit_type_SchemaInfoEvent_members(Visitor *v, SchemaInfoEvent *obj, Error **errp)
12948{
12949 Error *err = NULL;
12950
12951 visit_type_str(v, "arg-type", &obj->arg_type, &err);
12952 if (err) {
12953 goto out;
12954 }
12955
12956out:
12957 error_propagate(errp, err);
12958}
12959
12960void visit_type_SchemaInfoEvent(Visitor *v, const char *name, SchemaInfoEvent **obj, Error **errp)
12961{
12962 Error *err = NULL;
12963
12964 visit_start_struct(v, name, (void **)obj, sizeof(SchemaInfoEvent), &err);
12965 if (err) {
12966 goto out;
12967 }
12968 if (!*obj) {
12969 goto out_obj;
12970 }
12971 visit_type_SchemaInfoEvent_members(v, *obj, &err);
12972 if (err) {
12973 goto out_obj;
12974 }
12975 visit_check_struct(v, &err);
12976out_obj:
12977 visit_end_struct(v, (void **)obj);
12978 if (err && visit_is_input(v)) {
12979 qapi_free_SchemaInfoEvent(*obj);
12980 *obj = NULL;
12981 }
12982out:
12983 error_propagate(errp, err);
12984}
12985
12986void visit_type_SchemaInfoList(Visitor *v, const char *name, SchemaInfoList **obj, Error **errp)
12987{
12988 Error *err = NULL;
12989 SchemaInfoList *tail;
12990 size_t size = sizeof(**obj);
12991
12992 visit_start_list(v, name, (GenericList **)obj, size, &err);
12993 if (err) {
12994 goto out;
12995 }
12996
12997 for (tail = *obj; tail;
12998 tail = (SchemaInfoList *)visit_next_list(v, (GenericList *)tail, size)) {
12999 visit_type_SchemaInfo(v, NULL, &tail->value, &err);
13000 if (err) {
13001 break;
13002 }
13003 }
13004
13005 if (!err) {
13006 visit_check_list(v, &err);
13007 }
13008 visit_end_list(v, (void **)obj);
13009 if (err && visit_is_input(v)) {
13010 qapi_free_SchemaInfoList(*obj);
13011 *obj = NULL;
13012 }
13013out:
13014 error_propagate(errp, err);
13015}
13016
13017void visit_type_SchemaInfoObject_members(Visitor *v, SchemaInfoObject *obj, Error **errp)
13018{
13019 Error *err = NULL;
13020
13021 visit_type_SchemaInfoObjectMemberList(v, "members", &obj->members, &err);
13022 if (err) {
13023 goto out;
13024 }
13025 if (visit_optional(v, "tag", &obj->has_tag)) {
13026 visit_type_str(v, "tag", &obj->tag, &err);
13027 if (err) {
13028 goto out;
13029 }
13030 }
13031 if (visit_optional(v, "variants", &obj->has_variants)) {
13032 visit_type_SchemaInfoObjectVariantList(v, "variants", &obj->variants, &err);
13033 if (err) {
13034 goto out;
13035 }
13036 }
13037
13038out:
13039 error_propagate(errp, err);
13040}
13041
13042void visit_type_SchemaInfoObject(Visitor *v, const char *name, SchemaInfoObject **obj, Error **errp)
13043{
13044 Error *err = NULL;
13045
13046 visit_start_struct(v, name, (void **)obj, sizeof(SchemaInfoObject), &err);
13047 if (err) {
13048 goto out;
13049 }
13050 if (!*obj) {
13051 goto out_obj;
13052 }
13053 visit_type_SchemaInfoObject_members(v, *obj, &err);
13054 if (err) {
13055 goto out_obj;
13056 }
13057 visit_check_struct(v, &err);
13058out_obj:
13059 visit_end_struct(v, (void **)obj);
13060 if (err && visit_is_input(v)) {
13061 qapi_free_SchemaInfoObject(*obj);
13062 *obj = NULL;
13063 }
13064out:
13065 error_propagate(errp, err);
13066}
13067
13068void visit_type_SchemaInfoObjectMember_members(Visitor *v, SchemaInfoObjectMember *obj, Error **errp)
13069{
13070 Error *err = NULL;
13071
13072 visit_type_str(v, "name", &obj->name, &err);
13073 if (err) {
13074 goto out;
13075 }
13076 visit_type_str(v, "type", &obj->type, &err);
13077 if (err) {
13078 goto out;
13079 }
13080 if (visit_optional(v, "default", &obj->has_q_default)) {
13081 visit_type_any(v, "default", &obj->q_default, &err);
13082 if (err) {
13083 goto out;
13084 }
13085 }
13086
13087out:
13088 error_propagate(errp, err);
13089}
13090
13091void visit_type_SchemaInfoObjectMember(Visitor *v, const char *name, SchemaInfoObjectMember **obj, Error **errp)
13092{
13093 Error *err = NULL;
13094
13095 visit_start_struct(v, name, (void **)obj, sizeof(SchemaInfoObjectMember), &err);
13096 if (err) {
13097 goto out;
13098 }
13099 if (!*obj) {
13100 goto out_obj;
13101 }
13102 visit_type_SchemaInfoObjectMember_members(v, *obj, &err);
13103 if (err) {
13104 goto out_obj;
13105 }
13106 visit_check_struct(v, &err);
13107out_obj:
13108 visit_end_struct(v, (void **)obj);
13109 if (err && visit_is_input(v)) {
13110 qapi_free_SchemaInfoObjectMember(*obj);
13111 *obj = NULL;
13112 }
13113out:
13114 error_propagate(errp, err);
13115}
13116
13117void visit_type_SchemaInfoObjectMemberList(Visitor *v, const char *name, SchemaInfoObjectMemberList **obj, Error **errp)
13118{
13119 Error *err = NULL;
13120 SchemaInfoObjectMemberList *tail;
13121 size_t size = sizeof(**obj);
13122
13123 visit_start_list(v, name, (GenericList **)obj, size, &err);
13124 if (err) {
13125 goto out;
13126 }
13127
13128 for (tail = *obj; tail;
13129 tail = (SchemaInfoObjectMemberList *)visit_next_list(v, (GenericList *)tail, size)) {
13130 visit_type_SchemaInfoObjectMember(v, NULL, &tail->value, &err);
13131 if (err) {
13132 break;
13133 }
13134 }
13135
13136 if (!err) {
13137 visit_check_list(v, &err);
13138 }
13139 visit_end_list(v, (void **)obj);
13140 if (err && visit_is_input(v)) {
13141 qapi_free_SchemaInfoObjectMemberList(*obj);
13142 *obj = NULL;
13143 }
13144out:
13145 error_propagate(errp, err);
13146}
13147
13148void visit_type_SchemaInfoObjectVariant_members(Visitor *v, SchemaInfoObjectVariant *obj, Error **errp)
13149{
13150 Error *err = NULL;
13151
13152 visit_type_str(v, "case", &obj->q_case, &err);
13153 if (err) {
13154 goto out;
13155 }
13156 visit_type_str(v, "type", &obj->type, &err);
13157 if (err) {
13158 goto out;
13159 }
13160
13161out:
13162 error_propagate(errp, err);
13163}
13164
13165void visit_type_SchemaInfoObjectVariant(Visitor *v, const char *name, SchemaInfoObjectVariant **obj, Error **errp)
13166{
13167 Error *err = NULL;
13168
13169 visit_start_struct(v, name, (void **)obj, sizeof(SchemaInfoObjectVariant), &err);
13170 if (err) {
13171 goto out;
13172 }
13173 if (!*obj) {
13174 goto out_obj;
13175 }
13176 visit_type_SchemaInfoObjectVariant_members(v, *obj, &err);
13177 if (err) {
13178 goto out_obj;
13179 }
13180 visit_check_struct(v, &err);
13181out_obj:
13182 visit_end_struct(v, (void **)obj);
13183 if (err && visit_is_input(v)) {
13184 qapi_free_SchemaInfoObjectVariant(*obj);
13185 *obj = NULL;
13186 }
13187out:
13188 error_propagate(errp, err);
13189}
13190
13191void visit_type_SchemaInfoObjectVariantList(Visitor *v, const char *name, SchemaInfoObjectVariantList **obj, Error **errp)
13192{
13193 Error *err = NULL;
13194 SchemaInfoObjectVariantList *tail;
13195 size_t size = sizeof(**obj);
13196
13197 visit_start_list(v, name, (GenericList **)obj, size, &err);
13198 if (err) {
13199 goto out;
13200 }
13201
13202 for (tail = *obj; tail;
13203 tail = (SchemaInfoObjectVariantList *)visit_next_list(v, (GenericList *)tail, size)) {
13204 visit_type_SchemaInfoObjectVariant(v, NULL, &tail->value, &err);
13205 if (err) {
13206 break;
13207 }
13208 }
13209
13210 if (!err) {
13211 visit_check_list(v, &err);
13212 }
13213 visit_end_list(v, (void **)obj);
13214 if (err && visit_is_input(v)) {
13215 qapi_free_SchemaInfoObjectVariantList(*obj);
13216 *obj = NULL;
13217 }
13218out:
13219 error_propagate(errp, err);
13220}
13221
13222void visit_type_SchemaMetaType(Visitor *v, const char *name, SchemaMetaType *obj, Error **errp)
13223{
13224 int value = *obj;
13225 visit_type_enum(v, name, &value, SchemaMetaType_lookup, errp);
13226 *obj = value;
13227}
13228
13229void visit_type_SnapshotInfo_members(Visitor *v, SnapshotInfo *obj, Error **errp)
13230{
13231 Error *err = NULL;
13232
13233 visit_type_str(v, "id", &obj->id, &err);
13234 if (err) {
13235 goto out;
13236 }
13237 visit_type_str(v, "name", &obj->name, &err);
13238 if (err) {
13239 goto out;
13240 }
13241 visit_type_int(v, "vm-state-size", &obj->vm_state_size, &err);
13242 if (err) {
13243 goto out;
13244 }
13245 visit_type_int(v, "date-sec", &obj->date_sec, &err);
13246 if (err) {
13247 goto out;
13248 }
13249 visit_type_int(v, "date-nsec", &obj->date_nsec, &err);
13250 if (err) {
13251 goto out;
13252 }
13253 visit_type_int(v, "vm-clock-sec", &obj->vm_clock_sec, &err);
13254 if (err) {
13255 goto out;
13256 }
13257 visit_type_int(v, "vm-clock-nsec", &obj->vm_clock_nsec, &err);
13258 if (err) {
13259 goto out;
13260 }
13261
13262out:
13263 error_propagate(errp, err);
13264}
13265
13266void visit_type_SnapshotInfo(Visitor *v, const char *name, SnapshotInfo **obj, Error **errp)
13267{
13268 Error *err = NULL;
13269
13270 visit_start_struct(v, name, (void **)obj, sizeof(SnapshotInfo), &err);
13271 if (err) {
13272 goto out;
13273 }
13274 if (!*obj) {
13275 goto out_obj;
13276 }
13277 visit_type_SnapshotInfo_members(v, *obj, &err);
13278 if (err) {
13279 goto out_obj;
13280 }
13281 visit_check_struct(v, &err);
13282out_obj:
13283 visit_end_struct(v, (void **)obj);
13284 if (err && visit_is_input(v)) {
13285 qapi_free_SnapshotInfo(*obj);
13286 *obj = NULL;
13287 }
13288out:
13289 error_propagate(errp, err);
13290}
13291
13292void visit_type_SnapshotInfoList(Visitor *v, const char *name, SnapshotInfoList **obj, Error **errp)
13293{
13294 Error *err = NULL;
13295 SnapshotInfoList *tail;
13296 size_t size = sizeof(**obj);
13297
13298 visit_start_list(v, name, (GenericList **)obj, size, &err);
13299 if (err) {
13300 goto out;
13301 }
13302
13303 for (tail = *obj; tail;
13304 tail = (SnapshotInfoList *)visit_next_list(v, (GenericList *)tail, size)) {
13305 visit_type_SnapshotInfo(v, NULL, &tail->value, &err);
13306 if (err) {
13307 break;
13308 }
13309 }
13310
13311 if (!err) {
13312 visit_check_list(v, &err);
13313 }
13314 visit_end_list(v, (void **)obj);
13315 if (err && visit_is_input(v)) {
13316 qapi_free_SnapshotInfoList(*obj);
13317 *obj = NULL;
13318 }
13319out:
13320 error_propagate(errp, err);
13321}
13322
13323void visit_type_SocketAddress_members(Visitor *v, SocketAddress *obj, Error **errp)
13324{
13325 Error *err = NULL;
13326
13327 visit_type_q_obj_SocketAddress_base_members(v, (q_obj_SocketAddress_base *)obj, &err);
13328 if (err) {
13329 goto out;
13330 }
13331 switch (obj->type) {
13332 case SOCKET_ADDRESS_TYPE_INET:
13333 visit_type_InetSocketAddress_members(v, &obj->u.inet, &err);
13334 break;
13335 case SOCKET_ADDRESS_TYPE_UNIX:
13336 visit_type_UnixSocketAddress_members(v, &obj->u.q_unix, &err);
13337 break;
13338 case SOCKET_ADDRESS_TYPE_VSOCK:
13339 visit_type_VsockSocketAddress_members(v, &obj->u.vsock, &err);
13340 break;
13341 case SOCKET_ADDRESS_TYPE_FD:
13342 visit_type_String_members(v, &obj->u.fd, &err);
13343 break;
13344 default:
13345 abort();
13346 }
13347
13348out:
13349 error_propagate(errp, err);
13350}
13351
13352void visit_type_SocketAddress(Visitor *v, const char *name, SocketAddress **obj, Error **errp)
13353{
13354 Error *err = NULL;
13355
13356 visit_start_struct(v, name, (void **)obj, sizeof(SocketAddress), &err);
13357 if (err) {
13358 goto out;
13359 }
13360 if (!*obj) {
13361 goto out_obj;
13362 }
13363 visit_type_SocketAddress_members(v, *obj, &err);
13364 if (err) {
13365 goto out_obj;
13366 }
13367 visit_check_struct(v, &err);
13368out_obj:
13369 visit_end_struct(v, (void **)obj);
13370 if (err && visit_is_input(v)) {
13371 qapi_free_SocketAddress(*obj);
13372 *obj = NULL;
13373 }
13374out:
13375 error_propagate(errp, err);
13376}
13377
13378void visit_type_SocketAddressLegacy_members(Visitor *v, SocketAddressLegacy *obj, Error **errp)
13379{
13380 Error *err = NULL;
13381
13382 visit_type_SocketAddressLegacyKind(v, "type", &obj->type, &err);
13383 if (err) {
13384 goto out;
13385 }
13386 switch (obj->type) {
13387 case SOCKET_ADDRESS_LEGACY_KIND_INET:
13388 visit_type_q_obj_InetSocketAddress_wrapper_members(v, &obj->u.inet, &err);
13389 break;
13390 case SOCKET_ADDRESS_LEGACY_KIND_UNIX:
13391 visit_type_q_obj_UnixSocketAddress_wrapper_members(v, &obj->u.q_unix, &err);
13392 break;
13393 case SOCKET_ADDRESS_LEGACY_KIND_VSOCK:
13394 visit_type_q_obj_VsockSocketAddress_wrapper_members(v, &obj->u.vsock, &err);
13395 break;
13396 case SOCKET_ADDRESS_LEGACY_KIND_FD:
13397 visit_type_q_obj_String_wrapper_members(v, &obj->u.fd, &err);
13398 break;
13399 default:
13400 abort();
13401 }
13402
13403out:
13404 error_propagate(errp, err);
13405}
13406
13407void visit_type_SocketAddressLegacy(Visitor *v, const char *name, SocketAddressLegacy **obj, Error **errp)
13408{
13409 Error *err = NULL;
13410
13411 visit_start_struct(v, name, (void **)obj, sizeof(SocketAddressLegacy), &err);
13412 if (err) {
13413 goto out;
13414 }
13415 if (!*obj) {
13416 goto out_obj;
13417 }
13418 visit_type_SocketAddressLegacy_members(v, *obj, &err);
13419 if (err) {
13420 goto out_obj;
13421 }
13422 visit_check_struct(v, &err);
13423out_obj:
13424 visit_end_struct(v, (void **)obj);
13425 if (err && visit_is_input(v)) {
13426 qapi_free_SocketAddressLegacy(*obj);
13427 *obj = NULL;
13428 }
13429out:
13430 error_propagate(errp, err);
13431}
13432
13433void visit_type_SocketAddressLegacyKind(Visitor *v, const char *name, SocketAddressLegacyKind *obj, Error **errp)
13434{
13435 int value = *obj;
13436 visit_type_enum(v, name, &value, SocketAddressLegacyKind_lookup, errp);
13437 *obj = value;
13438}
13439
13440void visit_type_SocketAddressList(Visitor *v, const char *name, SocketAddressList **obj, Error **errp)
13441{
13442 Error *err = NULL;
13443 SocketAddressList *tail;
13444 size_t size = sizeof(**obj);
13445
13446 visit_start_list(v, name, (GenericList **)obj, size, &err);
13447 if (err) {
13448 goto out;
13449 }
13450
13451 for (tail = *obj; tail;
13452 tail = (SocketAddressList *)visit_next_list(v, (GenericList *)tail, size)) {
13453 visit_type_SocketAddress(v, NULL, &tail->value, &err);
13454 if (err) {
13455 break;
13456 }
13457 }
13458
13459 if (!err) {
13460 visit_check_list(v, &err);
13461 }
13462 visit_end_list(v, (void **)obj);
13463 if (err && visit_is_input(v)) {
13464 qapi_free_SocketAddressList(*obj);
13465 *obj = NULL;
13466 }
13467out:
13468 error_propagate(errp, err);
13469}
13470
13471void visit_type_SocketAddressType(Visitor *v, const char *name, SocketAddressType *obj, Error **errp)
13472{
13473 int value = *obj;
13474 visit_type_enum(v, name, &value, SocketAddressType_lookup, errp);
13475 *obj = value;
13476}
13477
13478void visit_type_SpiceBasicInfo_members(Visitor *v, SpiceBasicInfo *obj, Error **errp)
13479{
13480 Error *err = NULL;
13481
13482 visit_type_str(v, "host", &obj->host, &err);
13483 if (err) {
13484 goto out;
13485 }
13486 visit_type_str(v, "port", &obj->port, &err);
13487 if (err) {
13488 goto out;
13489 }
13490 visit_type_NetworkAddressFamily(v, "family", &obj->family, &err);
13491 if (err) {
13492 goto out;
13493 }
13494
13495out:
13496 error_propagate(errp, err);
13497}
13498
13499void visit_type_SpiceBasicInfo(Visitor *v, const char *name, SpiceBasicInfo **obj, Error **errp)
13500{
13501 Error *err = NULL;
13502
13503 visit_start_struct(v, name, (void **)obj, sizeof(SpiceBasicInfo), &err);
13504 if (err) {
13505 goto out;
13506 }
13507 if (!*obj) {
13508 goto out_obj;
13509 }
13510 visit_type_SpiceBasicInfo_members(v, *obj, &err);
13511 if (err) {
13512 goto out_obj;
13513 }
13514 visit_check_struct(v, &err);
13515out_obj:
13516 visit_end_struct(v, (void **)obj);
13517 if (err && visit_is_input(v)) {
13518 qapi_free_SpiceBasicInfo(*obj);
13519 *obj = NULL;
13520 }
13521out:
13522 error_propagate(errp, err);
13523}
13524
13525void visit_type_SpiceChannel_members(Visitor *v, SpiceChannel *obj, Error **errp)
13526{
13527 Error *err = NULL;
13528
13529 visit_type_SpiceBasicInfo_members(v, (SpiceBasicInfo *)obj, &err);
13530 if (err) {
13531 goto out;
13532 }
13533 visit_type_int(v, "connection-id", &obj->connection_id, &err);
13534 if (err) {
13535 goto out;
13536 }
13537 visit_type_int(v, "channel-type", &obj->channel_type, &err);
13538 if (err) {
13539 goto out;
13540 }
13541 visit_type_int(v, "channel-id", &obj->channel_id, &err);
13542 if (err) {
13543 goto out;
13544 }
13545 visit_type_bool(v, "tls", &obj->tls, &err);
13546 if (err) {
13547 goto out;
13548 }
13549
13550out:
13551 error_propagate(errp, err);
13552}
13553
13554void visit_type_SpiceChannel(Visitor *v, const char *name, SpiceChannel **obj, Error **errp)
13555{
13556 Error *err = NULL;
13557
13558 visit_start_struct(v, name, (void **)obj, sizeof(SpiceChannel), &err);
13559 if (err) {
13560 goto out;
13561 }
13562 if (!*obj) {
13563 goto out_obj;
13564 }
13565 visit_type_SpiceChannel_members(v, *obj, &err);
13566 if (err) {
13567 goto out_obj;
13568 }
13569 visit_check_struct(v, &err);
13570out_obj:
13571 visit_end_struct(v, (void **)obj);
13572 if (err && visit_is_input(v)) {
13573 qapi_free_SpiceChannel(*obj);
13574 *obj = NULL;
13575 }
13576out:
13577 error_propagate(errp, err);
13578}
13579
13580void visit_type_SpiceChannelList(Visitor *v, const char *name, SpiceChannelList **obj, Error **errp)
13581{
13582 Error *err = NULL;
13583 SpiceChannelList *tail;
13584 size_t size = sizeof(**obj);
13585
13586 visit_start_list(v, name, (GenericList **)obj, size, &err);
13587 if (err) {
13588 goto out;
13589 }
13590
13591 for (tail = *obj; tail;
13592 tail = (SpiceChannelList *)visit_next_list(v, (GenericList *)tail, size)) {
13593 visit_type_SpiceChannel(v, NULL, &tail->value, &err);
13594 if (err) {
13595 break;
13596 }
13597 }
13598
13599 if (!err) {
13600 visit_check_list(v, &err);
13601 }
13602 visit_end_list(v, (void **)obj);
13603 if (err && visit_is_input(v)) {
13604 qapi_free_SpiceChannelList(*obj);
13605 *obj = NULL;
13606 }
13607out:
13608 error_propagate(errp, err);
13609}
13610
13611void visit_type_SpiceInfo_members(Visitor *v, SpiceInfo *obj, Error **errp)
13612{
13613 Error *err = NULL;
13614
13615 visit_type_bool(v, "enabled", &obj->enabled, &err);
13616 if (err) {
13617 goto out;
13618 }
13619 visit_type_bool(v, "migrated", &obj->migrated, &err);
13620 if (err) {
13621 goto out;
13622 }
13623 if (visit_optional(v, "host", &obj->has_host)) {
13624 visit_type_str(v, "host", &obj->host, &err);
13625 if (err) {
13626 goto out;
13627 }
13628 }
13629 if (visit_optional(v, "port", &obj->has_port)) {
13630 visit_type_int(v, "port", &obj->port, &err);
13631 if (err) {
13632 goto out;
13633 }
13634 }
13635 if (visit_optional(v, "tls-port", &obj->has_tls_port)) {
13636 visit_type_int(v, "tls-port", &obj->tls_port, &err);
13637 if (err) {
13638 goto out;
13639 }
13640 }
13641 if (visit_optional(v, "auth", &obj->has_auth)) {
13642 visit_type_str(v, "auth", &obj->auth, &err);
13643 if (err) {
13644 goto out;
13645 }
13646 }
13647 if (visit_optional(v, "compiled-version", &obj->has_compiled_version)) {
13648 visit_type_str(v, "compiled-version", &obj->compiled_version, &err);
13649 if (err) {
13650 goto out;
13651 }
13652 }
13653 visit_type_SpiceQueryMouseMode(v, "mouse-mode", &obj->mouse_mode, &err);
13654 if (err) {
13655 goto out;
13656 }
13657 if (visit_optional(v, "channels", &obj->has_channels)) {
13658 visit_type_SpiceChannelList(v, "channels", &obj->channels, &err);
13659 if (err) {
13660 goto out;
13661 }
13662 }
13663
13664out:
13665 error_propagate(errp, err);
13666}
13667
13668void visit_type_SpiceInfo(Visitor *v, const char *name, SpiceInfo **obj, Error **errp)
13669{
13670 Error *err = NULL;
13671
13672 visit_start_struct(v, name, (void **)obj, sizeof(SpiceInfo), &err);
13673 if (err) {
13674 goto out;
13675 }
13676 if (!*obj) {
13677 goto out_obj;
13678 }
13679 visit_type_SpiceInfo_members(v, *obj, &err);
13680 if (err) {
13681 goto out_obj;
13682 }
13683 visit_check_struct(v, &err);
13684out_obj:
13685 visit_end_struct(v, (void **)obj);
13686 if (err && visit_is_input(v)) {
13687 qapi_free_SpiceInfo(*obj);
13688 *obj = NULL;
13689 }
13690out:
13691 error_propagate(errp, err);
13692}
13693
13694void visit_type_SpiceQueryMouseMode(Visitor *v, const char *name, SpiceQueryMouseMode *obj, Error **errp)
13695{
13696 int value = *obj;
13697 visit_type_enum(v, name, &value, SpiceQueryMouseMode_lookup, errp);
13698 *obj = value;
13699}
13700
13701void visit_type_SpiceServerInfo_members(Visitor *v, SpiceServerInfo *obj, Error **errp)
13702{
13703 Error *err = NULL;
13704
13705 visit_type_SpiceBasicInfo_members(v, (SpiceBasicInfo *)obj, &err);
13706 if (err) {
13707 goto out;
13708 }
13709 if (visit_optional(v, "auth", &obj->has_auth)) {
13710 visit_type_str(v, "auth", &obj->auth, &err);
13711 if (err) {
13712 goto out;
13713 }
13714 }
13715
13716out:
13717 error_propagate(errp, err);
13718}
13719
13720void visit_type_SpiceServerInfo(Visitor *v, const char *name, SpiceServerInfo **obj, Error **errp)
13721{
13722 Error *err = NULL;
13723
13724 visit_start_struct(v, name, (void **)obj, sizeof(SpiceServerInfo), &err);
13725 if (err) {
13726 goto out;
13727 }
13728 if (!*obj) {
13729 goto out_obj;
13730 }
13731 visit_type_SpiceServerInfo_members(v, *obj, &err);
13732 if (err) {
13733 goto out_obj;
13734 }
13735 visit_check_struct(v, &err);
13736out_obj:
13737 visit_end_struct(v, (void **)obj);
13738 if (err && visit_is_input(v)) {
13739 qapi_free_SpiceServerInfo(*obj);
13740 *obj = NULL;
13741 }
13742out:
13743 error_propagate(errp, err);
13744}
13745
13746void visit_type_StatusInfo_members(Visitor *v, StatusInfo *obj, Error **errp)
13747{
13748 Error *err = NULL;
13749
13750 visit_type_bool(v, "running", &obj->running, &err);
13751 if (err) {
13752 goto out;
13753 }
13754 visit_type_bool(v, "singlestep", &obj->singlestep, &err);
13755 if (err) {
13756 goto out;
13757 }
13758 visit_type_RunState(v, "status", &obj->status, &err);
13759 if (err) {
13760 goto out;
13761 }
13762
13763out:
13764 error_propagate(errp, err);
13765}
13766
13767void visit_type_StatusInfo(Visitor *v, const char *name, StatusInfo **obj, Error **errp)
13768{
13769 Error *err = NULL;
13770
13771 visit_start_struct(v, name, (void **)obj, sizeof(StatusInfo), &err);
13772 if (err) {
13773 goto out;
13774 }
13775 if (!*obj) {
13776 goto out_obj;
13777 }
13778 visit_type_StatusInfo_members(v, *obj, &err);
13779 if (err) {
13780 goto out_obj;
13781 }
13782 visit_check_struct(v, &err);
13783out_obj:
13784 visit_end_struct(v, (void **)obj);
13785 if (err && visit_is_input(v)) {
13786 qapi_free_StatusInfo(*obj);
13787 *obj = NULL;
13788 }
13789out:
13790 error_propagate(errp, err);
13791}
13792
13793void visit_type_StrOrNull(Visitor *v, const char *name, StrOrNull **obj, Error **errp)
13794{
13795 Error *err = NULL;
13796
13797 visit_start_alternate(v, name, (GenericAlternate **)obj, sizeof(**obj),
13798 &err);
13799 if (err) {
13800 goto out;
13801 }
13802 if (!*obj) {
13803 goto out_obj;
13804 }
13805 switch ((*obj)->type) {
13806 case QTYPE_QSTRING:
13807 visit_type_str(v, name, &(*obj)->u.s, &err);
13808 break;
13809 case QTYPE_QNULL:
13810 visit_type_null(v, name, &(*obj)->u.n, &err);
13811 break;
13812 case QTYPE_NONE:
13813 abort();
13814 default:
13815 error_setg(&err, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
13816 "StrOrNull");
13817 }
13818out_obj:
13819 visit_end_alternate(v, (void **)obj);
13820 if (err && visit_is_input(v)) {
13821 qapi_free_StrOrNull(*obj);
13822 *obj = NULL;
13823 }
13824out:
13825 error_propagate(errp, err);
13826}
13827
13828void visit_type_String_members(Visitor *v, String *obj, Error **errp)
13829{
13830 Error *err = NULL;
13831
13832 visit_type_str(v, "str", &obj->str, &err);
13833 if (err) {
13834 goto out;
13835 }
13836
13837out:
13838 error_propagate(errp, err);
13839}
13840
13841void visit_type_String(Visitor *v, const char *name, String **obj, Error **errp)
13842{
13843 Error *err = NULL;
13844
13845 visit_start_struct(v, name, (void **)obj, sizeof(String), &err);
13846 if (err) {
13847 goto out;
13848 }
13849 if (!*obj) {
13850 goto out_obj;
13851 }
13852 visit_type_String_members(v, *obj, &err);
13853 if (err) {
13854 goto out_obj;
13855 }
13856 visit_check_struct(v, &err);
13857out_obj:
13858 visit_end_struct(v, (void **)obj);
13859 if (err && visit_is_input(v)) {
13860 qapi_free_String(*obj);
13861 *obj = NULL;
13862 }
13863out:
13864 error_propagate(errp, err);
13865}
13866
13867void visit_type_StringList(Visitor *v, const char *name, StringList **obj, Error **errp)
13868{
13869 Error *err = NULL;
13870 StringList *tail;
13871 size_t size = sizeof(**obj);
13872
13873 visit_start_list(v, name, (GenericList **)obj, size, &err);
13874 if (err) {
13875 goto out;
13876 }
13877
13878 for (tail = *obj; tail;
13879 tail = (StringList *)visit_next_list(v, (GenericList *)tail, size)) {
13880 visit_type_String(v, NULL, &tail->value, &err);
13881 if (err) {
13882 break;
13883 }
13884 }
13885
13886 if (!err) {
13887 visit_check_list(v, &err);
13888 }
13889 visit_end_list(v, (void **)obj);
13890 if (err && visit_is_input(v)) {
13891 qapi_free_StringList(*obj);
13892 *obj = NULL;
13893 }
13894out:
13895 error_propagate(errp, err);
13896}
13897
13898void visit_type_TPMInfo_members(Visitor *v, TPMInfo *obj, Error **errp)
13899{
13900 Error *err = NULL;
13901
13902 visit_type_str(v, "id", &obj->id, &err);
13903 if (err) {
13904 goto out;
13905 }
13906 visit_type_TpmModel(v, "model", &obj->model, &err);
13907 if (err) {
13908 goto out;
13909 }
13910 visit_type_TpmTypeOptions(v, "options", &obj->options, &err);
13911 if (err) {
13912 goto out;
13913 }
13914
13915out:
13916 error_propagate(errp, err);
13917}
13918
13919void visit_type_TPMInfo(Visitor *v, const char *name, TPMInfo **obj, Error **errp)
13920{
13921 Error *err = NULL;
13922
13923 visit_start_struct(v, name, (void **)obj, sizeof(TPMInfo), &err);
13924 if (err) {
13925 goto out;
13926 }
13927 if (!*obj) {
13928 goto out_obj;
13929 }
13930 visit_type_TPMInfo_members(v, *obj, &err);
13931 if (err) {
13932 goto out_obj;
13933 }
13934 visit_check_struct(v, &err);
13935out_obj:
13936 visit_end_struct(v, (void **)obj);
13937 if (err && visit_is_input(v)) {
13938 qapi_free_TPMInfo(*obj);
13939 *obj = NULL;
13940 }
13941out:
13942 error_propagate(errp, err);
13943}
13944
13945void visit_type_TPMInfoList(Visitor *v, const char *name, TPMInfoList **obj, Error **errp)
13946{
13947 Error *err = NULL;
13948 TPMInfoList *tail;
13949 size_t size = sizeof(**obj);
13950
13951 visit_start_list(v, name, (GenericList **)obj, size, &err);
13952 if (err) {
13953 goto out;
13954 }
13955
13956 for (tail = *obj; tail;
13957 tail = (TPMInfoList *)visit_next_list(v, (GenericList *)tail, size)) {
13958 visit_type_TPMInfo(v, NULL, &tail->value, &err);
13959 if (err) {
13960 break;
13961 }
13962 }
13963
13964 if (!err) {
13965 visit_check_list(v, &err);
13966 }
13967 visit_end_list(v, (void **)obj);
13968 if (err && visit_is_input(v)) {
13969 qapi_free_TPMInfoList(*obj);
13970 *obj = NULL;
13971 }
13972out:
13973 error_propagate(errp, err);
13974}
13975
13976void visit_type_TPMPassthroughOptions_members(Visitor *v, TPMPassthroughOptions *obj, Error **errp)
13977{
13978 Error *err = NULL;
13979
13980 if (visit_optional(v, "path", &obj->has_path)) {
13981 visit_type_str(v, "path", &obj->path, &err);
13982 if (err) {
13983 goto out;
13984 }
13985 }
13986 if (visit_optional(v, "cancel-path", &obj->has_cancel_path)) {
13987 visit_type_str(v, "cancel-path", &obj->cancel_path, &err);
13988 if (err) {
13989 goto out;
13990 }
13991 }
13992
13993out:
13994 error_propagate(errp, err);
13995}
13996
13997void visit_type_TPMPassthroughOptions(Visitor *v, const char *name, TPMPassthroughOptions **obj, Error **errp)
13998{
13999 Error *err = NULL;
14000
14001 visit_start_struct(v, name, (void **)obj, sizeof(TPMPassthroughOptions), &err);
14002 if (err) {
14003 goto out;
14004 }
14005 if (!*obj) {
14006 goto out_obj;
14007 }
14008 visit_type_TPMPassthroughOptions_members(v, *obj, &err);
14009 if (err) {
14010 goto out_obj;
14011 }
14012 visit_check_struct(v, &err);
14013out_obj:
14014 visit_end_struct(v, (void **)obj);
14015 if (err && visit_is_input(v)) {
14016 qapi_free_TPMPassthroughOptions(*obj);
14017 *obj = NULL;
14018 }
14019out:
14020 error_propagate(errp, err);
14021}
14022
14023void visit_type_TargetInfo_members(Visitor *v, TargetInfo *obj, Error **errp)
14024{
14025 Error *err = NULL;
14026
14027 visit_type_str(v, "arch", &obj->arch, &err);
14028 if (err) {
14029 goto out;
14030 }
14031
14032out:
14033 error_propagate(errp, err);
14034}
14035
14036void visit_type_TargetInfo(Visitor *v, const char *name, TargetInfo **obj, Error **errp)
14037{
14038 Error *err = NULL;
14039
14040 visit_start_struct(v, name, (void **)obj, sizeof(TargetInfo), &err);
14041 if (err) {
14042 goto out;
14043 }
14044 if (!*obj) {
14045 goto out_obj;
14046 }
14047 visit_type_TargetInfo_members(v, *obj, &err);
14048 if (err) {
14049 goto out_obj;
14050 }
14051 visit_check_struct(v, &err);
14052out_obj:
14053 visit_end_struct(v, (void **)obj);
14054 if (err && visit_is_input(v)) {
14055 qapi_free_TargetInfo(*obj);
14056 *obj = NULL;
14057 }
14058out:
14059 error_propagate(errp, err);
14060}
14061
14062void visit_type_TpmModel(Visitor *v, const char *name, TpmModel *obj, Error **errp)
14063{
14064 int value = *obj;
14065 visit_type_enum(v, name, &value, TpmModel_lookup, errp);
14066 *obj = value;
14067}
14068
14069void visit_type_TpmModelList(Visitor *v, const char *name, TpmModelList **obj, Error **errp)
14070{
14071 Error *err = NULL;
14072 TpmModelList *tail;
14073 size_t size = sizeof(**obj);
14074
14075 visit_start_list(v, name, (GenericList **)obj, size, &err);
14076 if (err) {
14077 goto out;
14078 }
14079
14080 for (tail = *obj; tail;
14081 tail = (TpmModelList *)visit_next_list(v, (GenericList *)tail, size)) {
14082 visit_type_TpmModel(v, NULL, &tail->value, &err);
14083 if (err) {
14084 break;
14085 }
14086 }
14087
14088 if (!err) {
14089 visit_check_list(v, &err);
14090 }
14091 visit_end_list(v, (void **)obj);
14092 if (err && visit_is_input(v)) {
14093 qapi_free_TpmModelList(*obj);
14094 *obj = NULL;
14095 }
14096out:
14097 error_propagate(errp, err);
14098}
14099
14100void visit_type_TpmType(Visitor *v, const char *name, TpmType *obj, Error **errp)
14101{
14102 int value = *obj;
14103 visit_type_enum(v, name, &value, TpmType_lookup, errp);
14104 *obj = value;
14105}
14106
14107void visit_type_TpmTypeList(Visitor *v, const char *name, TpmTypeList **obj, Error **errp)
14108{
14109 Error *err = NULL;
14110 TpmTypeList *tail;
14111 size_t size = sizeof(**obj);
14112
14113 visit_start_list(v, name, (GenericList **)obj, size, &err);
14114 if (err) {
14115 goto out;
14116 }
14117
14118 for (tail = *obj; tail;
14119 tail = (TpmTypeList *)visit_next_list(v, (GenericList *)tail, size)) {
14120 visit_type_TpmType(v, NULL, &tail->value, &err);
14121 if (err) {
14122 break;
14123 }
14124 }
14125
14126 if (!err) {
14127 visit_check_list(v, &err);
14128 }
14129 visit_end_list(v, (void **)obj);
14130 if (err && visit_is_input(v)) {
14131 qapi_free_TpmTypeList(*obj);
14132 *obj = NULL;
14133 }
14134out:
14135 error_propagate(errp, err);
14136}
14137
14138void visit_type_TpmTypeOptions_members(Visitor *v, TpmTypeOptions *obj, Error **errp)
14139{
14140 Error *err = NULL;
14141
14142 visit_type_TpmTypeOptionsKind(v, "type", &obj->type, &err);
14143 if (err) {
14144 goto out;
14145 }
14146 switch (obj->type) {
14147 case TPM_TYPE_OPTIONS_KIND_PASSTHROUGH:
14148 visit_type_q_obj_TPMPassthroughOptions_wrapper_members(v, &obj->u.passthrough, &err);
14149 break;
14150 default:
14151 abort();
14152 }
14153
14154out:
14155 error_propagate(errp, err);
14156}
14157
14158void visit_type_TpmTypeOptions(Visitor *v, const char *name, TpmTypeOptions **obj, Error **errp)
14159{
14160 Error *err = NULL;
14161
14162 visit_start_struct(v, name, (void **)obj, sizeof(TpmTypeOptions), &err);
14163 if (err) {
14164 goto out;
14165 }
14166 if (!*obj) {
14167 goto out_obj;
14168 }
14169 visit_type_TpmTypeOptions_members(v, *obj, &err);
14170 if (err) {
14171 goto out_obj;
14172 }
14173 visit_check_struct(v, &err);
14174out_obj:
14175 visit_end_struct(v, (void **)obj);
14176 if (err && visit_is_input(v)) {
14177 qapi_free_TpmTypeOptions(*obj);
14178 *obj = NULL;
14179 }
14180out:
14181 error_propagate(errp, err);
14182}
14183
14184void visit_type_TpmTypeOptionsKind(Visitor *v, const char *name, TpmTypeOptionsKind *obj, Error **errp)
14185{
14186 int value = *obj;
14187 visit_type_enum(v, name, &value, TpmTypeOptionsKind_lookup, errp);
14188 *obj = value;
14189}
14190
14191void visit_type_TraceEventInfo_members(Visitor *v, TraceEventInfo *obj, Error **errp)
14192{
14193 Error *err = NULL;
14194
14195 visit_type_str(v, "name", &obj->name, &err);
14196 if (err) {
14197 goto out;
14198 }
14199 visit_type_TraceEventState(v, "state", &obj->state, &err);
14200 if (err) {
14201 goto out;
14202 }
14203 visit_type_bool(v, "vcpu", &obj->vcpu, &err);
14204 if (err) {
14205 goto out;
14206 }
14207
14208out:
14209 error_propagate(errp, err);
14210}
14211
14212void visit_type_TraceEventInfo(Visitor *v, const char *name, TraceEventInfo **obj, Error **errp)
14213{
14214 Error *err = NULL;
14215
14216 visit_start_struct(v, name, (void **)obj, sizeof(TraceEventInfo), &err);
14217 if (err) {
14218 goto out;
14219 }
14220 if (!*obj) {
14221 goto out_obj;
14222 }
14223 visit_type_TraceEventInfo_members(v, *obj, &err);
14224 if (err) {
14225 goto out_obj;
14226 }
14227 visit_check_struct(v, &err);
14228out_obj:
14229 visit_end_struct(v, (void **)obj);
14230 if (err && visit_is_input(v)) {
14231 qapi_free_TraceEventInfo(*obj);
14232 *obj = NULL;
14233 }
14234out:
14235 error_propagate(errp, err);
14236}
14237
14238void visit_type_TraceEventInfoList(Visitor *v, const char *name, TraceEventInfoList **obj, Error **errp)
14239{
14240 Error *err = NULL;
14241 TraceEventInfoList *tail;
14242 size_t size = sizeof(**obj);
14243
14244 visit_start_list(v, name, (GenericList **)obj, size, &err);
14245 if (err) {
14246 goto out;
14247 }
14248
14249 for (tail = *obj; tail;
14250 tail = (TraceEventInfoList *)visit_next_list(v, (GenericList *)tail, size)) {
14251 visit_type_TraceEventInfo(v, NULL, &tail->value, &err);
14252 if (err) {
14253 break;
14254 }
14255 }
14256
14257 if (!err) {
14258 visit_check_list(v, &err);
14259 }
14260 visit_end_list(v, (void **)obj);
14261 if (err && visit_is_input(v)) {
14262 qapi_free_TraceEventInfoList(*obj);
14263 *obj = NULL;
14264 }
14265out:
14266 error_propagate(errp, err);
14267}
14268
14269void visit_type_TraceEventState(Visitor *v, const char *name, TraceEventState *obj, Error **errp)
14270{
14271 int value = *obj;
14272 visit_type_enum(v, name, &value, TraceEventState_lookup, errp);
14273 *obj = value;
14274}
14275
14276void visit_type_TransactionAction_members(Visitor *v, TransactionAction *obj, Error **errp)
14277{
14278 Error *err = NULL;
14279
14280 visit_type_TransactionActionKind(v, "type", &obj->type, &err);
14281 if (err) {
14282 goto out;
14283 }
14284 switch (obj->type) {
14285 case TRANSACTION_ACTION_KIND_ABORT:
14286 visit_type_q_obj_Abort_wrapper_members(v, &obj->u.abort, &err);
14287 break;
14288 case TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_ADD:
14289 visit_type_q_obj_BlockDirtyBitmapAdd_wrapper_members(v, &obj->u.block_dirty_bitmap_add, &err);
14290 break;
14291 case TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_CLEAR:
14292 visit_type_q_obj_BlockDirtyBitmap_wrapper_members(v, &obj->u.block_dirty_bitmap_clear, &err);
14293 break;
14294 case TRANSACTION_ACTION_KIND_BLOCKDEV_BACKUP:
14295 visit_type_q_obj_BlockdevBackup_wrapper_members(v, &obj->u.blockdev_backup, &err);
14296 break;
14297 case TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT:
14298 visit_type_q_obj_BlockdevSnapshot_wrapper_members(v, &obj->u.blockdev_snapshot, &err);
14299 break;
14300 case TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_INTERNAL_SYNC:
14301 visit_type_q_obj_BlockdevSnapshotInternal_wrapper_members(v, &obj->u.blockdev_snapshot_internal_sync, &err);
14302 break;
14303 case TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_SYNC:
14304 visit_type_q_obj_BlockdevSnapshotSync_wrapper_members(v, &obj->u.blockdev_snapshot_sync, &err);
14305 break;
14306 case TRANSACTION_ACTION_KIND_DRIVE_BACKUP:
14307 visit_type_q_obj_DriveBackup_wrapper_members(v, &obj->u.drive_backup, &err);
14308 break;
14309 default:
14310 abort();
14311 }
14312
14313out:
14314 error_propagate(errp, err);
14315}
14316
14317void visit_type_TransactionAction(Visitor *v, const char *name, TransactionAction **obj, Error **errp)
14318{
14319 Error *err = NULL;
14320
14321 visit_start_struct(v, name, (void **)obj, sizeof(TransactionAction), &err);
14322 if (err) {
14323 goto out;
14324 }
14325 if (!*obj) {
14326 goto out_obj;
14327 }
14328 visit_type_TransactionAction_members(v, *obj, &err);
14329 if (err) {
14330 goto out_obj;
14331 }
14332 visit_check_struct(v, &err);
14333out_obj:
14334 visit_end_struct(v, (void **)obj);
14335 if (err && visit_is_input(v)) {
14336 qapi_free_TransactionAction(*obj);
14337 *obj = NULL;
14338 }
14339out:
14340 error_propagate(errp, err);
14341}
14342
14343void visit_type_TransactionActionKind(Visitor *v, const char *name, TransactionActionKind *obj, Error **errp)
14344{
14345 int value = *obj;
14346 visit_type_enum(v, name, &value, TransactionActionKind_lookup, errp);
14347 *obj = value;
14348}
14349
14350void visit_type_TransactionActionList(Visitor *v, const char *name, TransactionActionList **obj, Error **errp)
14351{
14352 Error *err = NULL;
14353 TransactionActionList *tail;
14354 size_t size = sizeof(**obj);
14355
14356 visit_start_list(v, name, (GenericList **)obj, size, &err);
14357 if (err) {
14358 goto out;
14359 }
14360
14361 for (tail = *obj; tail;
14362 tail = (TransactionActionList *)visit_next_list(v, (GenericList *)tail, size)) {
14363 visit_type_TransactionAction(v, NULL, &tail->value, &err);
14364 if (err) {
14365 break;
14366 }
14367 }
14368
14369 if (!err) {
14370 visit_check_list(v, &err);
14371 }
14372 visit_end_list(v, (void **)obj);
14373 if (err && visit_is_input(v)) {
14374 qapi_free_TransactionActionList(*obj);
14375 *obj = NULL;
14376 }
14377out:
14378 error_propagate(errp, err);
14379}
14380
14381void visit_type_TransactionProperties_members(Visitor *v, TransactionProperties *obj, Error **errp)
14382{
14383 Error *err = NULL;
14384
14385 if (visit_optional(v, "completion-mode", &obj->has_completion_mode)) {
14386 visit_type_ActionCompletionMode(v, "completion-mode", &obj->completion_mode, &err);
14387 if (err) {
14388 goto out;
14389 }
14390 }
14391
14392out:
14393 error_propagate(errp, err);
14394}
14395
14396void visit_type_TransactionProperties(Visitor *v, const char *name, TransactionProperties **obj, Error **errp)
14397{
14398 Error *err = NULL;
14399
14400 visit_start_struct(v, name, (void **)obj, sizeof(TransactionProperties), &err);
14401 if (err) {
14402 goto out;
14403 }
14404 if (!*obj) {
14405 goto out_obj;
14406 }
14407 visit_type_TransactionProperties_members(v, *obj, &err);
14408 if (err) {
14409 goto out_obj;
14410 }
14411 visit_check_struct(v, &err);
14412out_obj:
14413 visit_end_struct(v, (void **)obj);
14414 if (err && visit_is_input(v)) {
14415 qapi_free_TransactionProperties(*obj);
14416 *obj = NULL;
14417 }
14418out:
14419 error_propagate(errp, err);
14420}
14421
14422void visit_type_UnixSocketAddress_members(Visitor *v, UnixSocketAddress *obj, Error **errp)
14423{
14424 Error *err = NULL;
14425
14426 visit_type_str(v, "path", &obj->path, &err);
14427 if (err) {
14428 goto out;
14429 }
14430
14431out:
14432 error_propagate(errp, err);
14433}
14434
14435void visit_type_UnixSocketAddress(Visitor *v, const char *name, UnixSocketAddress **obj, Error **errp)
14436{
14437 Error *err = NULL;
14438
14439 visit_start_struct(v, name, (void **)obj, sizeof(UnixSocketAddress), &err);
14440 if (err) {
14441 goto out;
14442 }
14443 if (!*obj) {
14444 goto out_obj;
14445 }
14446 visit_type_UnixSocketAddress_members(v, *obj, &err);
14447 if (err) {
14448 goto out_obj;
14449 }
14450 visit_check_struct(v, &err);
14451out_obj:
14452 visit_end_struct(v, (void **)obj);
14453 if (err && visit_is_input(v)) {
14454 qapi_free_UnixSocketAddress(*obj);
14455 *obj = NULL;
14456 }
14457out:
14458 error_propagate(errp, err);
14459}
14460
14461void visit_type_UuidInfo_members(Visitor *v, UuidInfo *obj, Error **errp)
14462{
14463 Error *err = NULL;
14464
14465 visit_type_str(v, "UUID", &obj->UUID, &err);
14466 if (err) {
14467 goto out;
14468 }
14469
14470out:
14471 error_propagate(errp, err);
14472}
14473
14474void visit_type_UuidInfo(Visitor *v, const char *name, UuidInfo **obj, Error **errp)
14475{
14476 Error *err = NULL;
14477
14478 visit_start_struct(v, name, (void **)obj, sizeof(UuidInfo), &err);
14479 if (err) {
14480 goto out;
14481 }
14482 if (!*obj) {
14483 goto out_obj;
14484 }
14485 visit_type_UuidInfo_members(v, *obj, &err);
14486 if (err) {
14487 goto out_obj;
14488 }
14489 visit_check_struct(v, &err);
14490out_obj:
14491 visit_end_struct(v, (void **)obj);
14492 if (err && visit_is_input(v)) {
14493 qapi_free_UuidInfo(*obj);
14494 *obj = NULL;
14495 }
14496out:
14497 error_propagate(errp, err);
14498}
14499
14500void visit_type_VersionInfo_members(Visitor *v, VersionInfo *obj, Error **errp)
14501{
14502 Error *err = NULL;
14503
14504 visit_type_VersionTriple(v, "qemu", &obj->qemu, &err);
14505 if (err) {
14506 goto out;
14507 }
14508 visit_type_str(v, "package", &obj->package, &err);
14509 if (err) {
14510 goto out;
14511 }
14512
14513out:
14514 error_propagate(errp, err);
14515}
14516
14517void visit_type_VersionInfo(Visitor *v, const char *name, VersionInfo **obj, Error **errp)
14518{
14519 Error *err = NULL;
14520
14521 visit_start_struct(v, name, (void **)obj, sizeof(VersionInfo), &err);
14522 if (err) {
14523 goto out;
14524 }
14525 if (!*obj) {
14526 goto out_obj;
14527 }
14528 visit_type_VersionInfo_members(v, *obj, &err);
14529 if (err) {
14530 goto out_obj;
14531 }
14532 visit_check_struct(v, &err);
14533out_obj:
14534 visit_end_struct(v, (void **)obj);
14535 if (err && visit_is_input(v)) {
14536 qapi_free_VersionInfo(*obj);
14537 *obj = NULL;
14538 }
14539out:
14540 error_propagate(errp, err);
14541}
14542
14543void visit_type_VersionTriple_members(Visitor *v, VersionTriple *obj, Error **errp)
14544{
14545 Error *err = NULL;
14546
14547 visit_type_int(v, "major", &obj->major, &err);
14548 if (err) {
14549 goto out;
14550 }
14551 visit_type_int(v, "minor", &obj->minor, &err);
14552 if (err) {
14553 goto out;
14554 }
14555 visit_type_int(v, "micro", &obj->micro, &err);
14556 if (err) {
14557 goto out;
14558 }
14559
14560out:
14561 error_propagate(errp, err);
14562}
14563
14564void visit_type_VersionTriple(Visitor *v, const char *name, VersionTriple **obj, Error **errp)
14565{
14566 Error *err = NULL;
14567
14568 visit_start_struct(v, name, (void **)obj, sizeof(VersionTriple), &err);
14569 if (err) {
14570 goto out;
14571 }
14572 if (!*obj) {
14573 goto out_obj;
14574 }
14575 visit_type_VersionTriple_members(v, *obj, &err);
14576 if (err) {
14577 goto out_obj;
14578 }
14579 visit_check_struct(v, &err);
14580out_obj:
14581 visit_end_struct(v, (void **)obj);
14582 if (err && visit_is_input(v)) {
14583 qapi_free_VersionTriple(*obj);
14584 *obj = NULL;
14585 }
14586out:
14587 error_propagate(errp, err);
14588}
14589
14590void visit_type_VncBasicInfo_members(Visitor *v, VncBasicInfo *obj, Error **errp)
14591{
14592 Error *err = NULL;
14593
14594 visit_type_str(v, "host", &obj->host, &err);
14595 if (err) {
14596 goto out;
14597 }
14598 visit_type_str(v, "service", &obj->service, &err);
14599 if (err) {
14600 goto out;
14601 }
14602 visit_type_NetworkAddressFamily(v, "family", &obj->family, &err);
14603 if (err) {
14604 goto out;
14605 }
14606 visit_type_bool(v, "websocket", &obj->websocket, &err);
14607 if (err) {
14608 goto out;
14609 }
14610
14611out:
14612 error_propagate(errp, err);
14613}
14614
14615void visit_type_VncBasicInfo(Visitor *v, const char *name, VncBasicInfo **obj, Error **errp)
14616{
14617 Error *err = NULL;
14618
14619 visit_start_struct(v, name, (void **)obj, sizeof(VncBasicInfo), &err);
14620 if (err) {
14621 goto out;
14622 }
14623 if (!*obj) {
14624 goto out_obj;
14625 }
14626 visit_type_VncBasicInfo_members(v, *obj, &err);
14627 if (err) {
14628 goto out_obj;
14629 }
14630 visit_check_struct(v, &err);
14631out_obj:
14632 visit_end_struct(v, (void **)obj);
14633 if (err && visit_is_input(v)) {
14634 qapi_free_VncBasicInfo(*obj);
14635 *obj = NULL;
14636 }
14637out:
14638 error_propagate(errp, err);
14639}
14640
14641void visit_type_VncClientInfo_members(Visitor *v, VncClientInfo *obj, Error **errp)
14642{
14643 Error *err = NULL;
14644
14645 visit_type_VncBasicInfo_members(v, (VncBasicInfo *)obj, &err);
14646 if (err) {
14647 goto out;
14648 }
14649 if (visit_optional(v, "x509_dname", &obj->has_x509_dname)) {
14650 visit_type_str(v, "x509_dname", &obj->x509_dname, &err);
14651 if (err) {
14652 goto out;
14653 }
14654 }
14655 if (visit_optional(v, "sasl_username", &obj->has_sasl_username)) {
14656 visit_type_str(v, "sasl_username", &obj->sasl_username, &err);
14657 if (err) {
14658 goto out;
14659 }
14660 }
14661
14662out:
14663 error_propagate(errp, err);
14664}
14665
14666void visit_type_VncClientInfo(Visitor *v, const char *name, VncClientInfo **obj, Error **errp)
14667{
14668 Error *err = NULL;
14669
14670 visit_start_struct(v, name, (void **)obj, sizeof(VncClientInfo), &err);
14671 if (err) {
14672 goto out;
14673 }
14674 if (!*obj) {
14675 goto out_obj;
14676 }
14677 visit_type_VncClientInfo_members(v, *obj, &err);
14678 if (err) {
14679 goto out_obj;
14680 }
14681 visit_check_struct(v, &err);
14682out_obj:
14683 visit_end_struct(v, (void **)obj);
14684 if (err && visit_is_input(v)) {
14685 qapi_free_VncClientInfo(*obj);
14686 *obj = NULL;
14687 }
14688out:
14689 error_propagate(errp, err);
14690}
14691
14692void visit_type_VncClientInfoList(Visitor *v, const char *name, VncClientInfoList **obj, Error **errp)
14693{
14694 Error *err = NULL;
14695 VncClientInfoList *tail;
14696 size_t size = sizeof(**obj);
14697
14698 visit_start_list(v, name, (GenericList **)obj, size, &err);
14699 if (err) {
14700 goto out;
14701 }
14702
14703 for (tail = *obj; tail;
14704 tail = (VncClientInfoList *)visit_next_list(v, (GenericList *)tail, size)) {
14705 visit_type_VncClientInfo(v, NULL, &tail->value, &err);
14706 if (err) {
14707 break;
14708 }
14709 }
14710
14711 if (!err) {
14712 visit_check_list(v, &err);
14713 }
14714 visit_end_list(v, (void **)obj);
14715 if (err && visit_is_input(v)) {
14716 qapi_free_VncClientInfoList(*obj);
14717 *obj = NULL;
14718 }
14719out:
14720 error_propagate(errp, err);
14721}
14722
14723void visit_type_VncInfo_members(Visitor *v, VncInfo *obj, Error **errp)
14724{
14725 Error *err = NULL;
14726
14727 visit_type_bool(v, "enabled", &obj->enabled, &err);
14728 if (err) {
14729 goto out;
14730 }
14731 if (visit_optional(v, "host", &obj->has_host)) {
14732 visit_type_str(v, "host", &obj->host, &err);
14733 if (err) {
14734 goto out;
14735 }
14736 }
14737 if (visit_optional(v, "family", &obj->has_family)) {
14738 visit_type_NetworkAddressFamily(v, "family", &obj->family, &err);
14739 if (err) {
14740 goto out;
14741 }
14742 }
14743 if (visit_optional(v, "service", &obj->has_service)) {
14744 visit_type_str(v, "service", &obj->service, &err);
14745 if (err) {
14746 goto out;
14747 }
14748 }
14749 if (visit_optional(v, "auth", &obj->has_auth)) {
14750 visit_type_str(v, "auth", &obj->auth, &err);
14751 if (err) {
14752 goto out;
14753 }
14754 }
14755 if (visit_optional(v, "clients", &obj->has_clients)) {
14756 visit_type_VncClientInfoList(v, "clients", &obj->clients, &err);
14757 if (err) {
14758 goto out;
14759 }
14760 }
14761
14762out:
14763 error_propagate(errp, err);
14764}
14765
14766void visit_type_VncInfo(Visitor *v, const char *name, VncInfo **obj, Error **errp)
14767{
14768 Error *err = NULL;
14769
14770 visit_start_struct(v, name, (void **)obj, sizeof(VncInfo), &err);
14771 if (err) {
14772 goto out;
14773 }
14774 if (!*obj) {
14775 goto out_obj;
14776 }
14777 visit_type_VncInfo_members(v, *obj, &err);
14778 if (err) {
14779 goto out_obj;
14780 }
14781 visit_check_struct(v, &err);
14782out_obj:
14783 visit_end_struct(v, (void **)obj);
14784 if (err && visit_is_input(v)) {
14785 qapi_free_VncInfo(*obj);
14786 *obj = NULL;
14787 }
14788out:
14789 error_propagate(errp, err);
14790}
14791
14792void visit_type_VncInfo2_members(Visitor *v, VncInfo2 *obj, Error **errp)
14793{
14794 Error *err = NULL;
14795
14796 visit_type_str(v, "id", &obj->id, &err);
14797 if (err) {
14798 goto out;
14799 }
14800 visit_type_VncServerInfo2List(v, "server", &obj->server, &err);
14801 if (err) {
14802 goto out;
14803 }
14804 visit_type_VncClientInfoList(v, "clients", &obj->clients, &err);
14805 if (err) {
14806 goto out;
14807 }
14808 visit_type_VncPrimaryAuth(v, "auth", &obj->auth, &err);
14809 if (err) {
14810 goto out;
14811 }
14812 if (visit_optional(v, "vencrypt", &obj->has_vencrypt)) {
14813 visit_type_VncVencryptSubAuth(v, "vencrypt", &obj->vencrypt, &err);
14814 if (err) {
14815 goto out;
14816 }
14817 }
14818 if (visit_optional(v, "display", &obj->has_display)) {
14819 visit_type_str(v, "display", &obj->display, &err);
14820 if (err) {
14821 goto out;
14822 }
14823 }
14824
14825out:
14826 error_propagate(errp, err);
14827}
14828
14829void visit_type_VncInfo2(Visitor *v, const char *name, VncInfo2 **obj, Error **errp)
14830{
14831 Error *err = NULL;
14832
14833 visit_start_struct(v, name, (void **)obj, sizeof(VncInfo2), &err);
14834 if (err) {
14835 goto out;
14836 }
14837 if (!*obj) {
14838 goto out_obj;
14839 }
14840 visit_type_VncInfo2_members(v, *obj, &err);
14841 if (err) {
14842 goto out_obj;
14843 }
14844 visit_check_struct(v, &err);
14845out_obj:
14846 visit_end_struct(v, (void **)obj);
14847 if (err && visit_is_input(v)) {
14848 qapi_free_VncInfo2(*obj);
14849 *obj = NULL;
14850 }
14851out:
14852 error_propagate(errp, err);
14853}
14854
14855void visit_type_VncInfo2List(Visitor *v, const char *name, VncInfo2List **obj, Error **errp)
14856{
14857 Error *err = NULL;
14858 VncInfo2List *tail;
14859 size_t size = sizeof(**obj);
14860
14861 visit_start_list(v, name, (GenericList **)obj, size, &err);
14862 if (err) {
14863 goto out;
14864 }
14865
14866 for (tail = *obj; tail;
14867 tail = (VncInfo2List *)visit_next_list(v, (GenericList *)tail, size)) {
14868 visit_type_VncInfo2(v, NULL, &tail->value, &err);
14869 if (err) {
14870 break;
14871 }
14872 }
14873
14874 if (!err) {
14875 visit_check_list(v, &err);
14876 }
14877 visit_end_list(v, (void **)obj);
14878 if (err && visit_is_input(v)) {
14879 qapi_free_VncInfo2List(*obj);
14880 *obj = NULL;
14881 }
14882out:
14883 error_propagate(errp, err);
14884}
14885
14886void visit_type_VncPrimaryAuth(Visitor *v, const char *name, VncPrimaryAuth *obj, Error **errp)
14887{
14888 int value = *obj;
14889 visit_type_enum(v, name, &value, VncPrimaryAuth_lookup, errp);
14890 *obj = value;
14891}
14892
14893void visit_type_VncServerInfo_members(Visitor *v, VncServerInfo *obj, Error **errp)
14894{
14895 Error *err = NULL;
14896
14897 visit_type_VncBasicInfo_members(v, (VncBasicInfo *)obj, &err);
14898 if (err) {
14899 goto out;
14900 }
14901 if (visit_optional(v, "auth", &obj->has_auth)) {
14902 visit_type_str(v, "auth", &obj->auth, &err);
14903 if (err) {
14904 goto out;
14905 }
14906 }
14907
14908out:
14909 error_propagate(errp, err);
14910}
14911
14912void visit_type_VncServerInfo(Visitor *v, const char *name, VncServerInfo **obj, Error **errp)
14913{
14914 Error *err = NULL;
14915
14916 visit_start_struct(v, name, (void **)obj, sizeof(VncServerInfo), &err);
14917 if (err) {
14918 goto out;
14919 }
14920 if (!*obj) {
14921 goto out_obj;
14922 }
14923 visit_type_VncServerInfo_members(v, *obj, &err);
14924 if (err) {
14925 goto out_obj;
14926 }
14927 visit_check_struct(v, &err);
14928out_obj:
14929 visit_end_struct(v, (void **)obj);
14930 if (err && visit_is_input(v)) {
14931 qapi_free_VncServerInfo(*obj);
14932 *obj = NULL;
14933 }
14934out:
14935 error_propagate(errp, err);
14936}
14937
14938void visit_type_VncServerInfo2_members(Visitor *v, VncServerInfo2 *obj, Error **errp)
14939{
14940 Error *err = NULL;
14941
14942 visit_type_VncBasicInfo_members(v, (VncBasicInfo *)obj, &err);
14943 if (err) {
14944 goto out;
14945 }
14946 visit_type_VncPrimaryAuth(v, "auth", &obj->auth, &err);
14947 if (err) {
14948 goto out;
14949 }
14950 if (visit_optional(v, "vencrypt", &obj->has_vencrypt)) {
14951 visit_type_VncVencryptSubAuth(v, "vencrypt", &obj->vencrypt, &err);
14952 if (err) {
14953 goto out;
14954 }
14955 }
14956
14957out:
14958 error_propagate(errp, err);
14959}
14960
14961void visit_type_VncServerInfo2(Visitor *v, const char *name, VncServerInfo2 **obj, Error **errp)
14962{
14963 Error *err = NULL;
14964
14965 visit_start_struct(v, name, (void **)obj, sizeof(VncServerInfo2), &err);
14966 if (err) {
14967 goto out;
14968 }
14969 if (!*obj) {
14970 goto out_obj;
14971 }
14972 visit_type_VncServerInfo2_members(v, *obj, &err);
14973 if (err) {
14974 goto out_obj;
14975 }
14976 visit_check_struct(v, &err);
14977out_obj:
14978 visit_end_struct(v, (void **)obj);
14979 if (err && visit_is_input(v)) {
14980 qapi_free_VncServerInfo2(*obj);
14981 *obj = NULL;
14982 }
14983out:
14984 error_propagate(errp, err);
14985}
14986
14987void visit_type_VncServerInfo2List(Visitor *v, const char *name, VncServerInfo2List **obj, Error **errp)
14988{
14989 Error *err = NULL;
14990 VncServerInfo2List *tail;
14991 size_t size = sizeof(**obj);
14992
14993 visit_start_list(v, name, (GenericList **)obj, size, &err);
14994 if (err) {
14995 goto out;
14996 }
14997
14998 for (tail = *obj; tail;
14999 tail = (VncServerInfo2List *)visit_next_list(v, (GenericList *)tail, size)) {
15000 visit_type_VncServerInfo2(v, NULL, &tail->value, &err);
15001 if (err) {
15002 break;
15003 }
15004 }
15005
15006 if (!err) {
15007 visit_check_list(v, &err);
15008 }
15009 visit_end_list(v, (void **)obj);
15010 if (err && visit_is_input(v)) {
15011 qapi_free_VncServerInfo2List(*obj);
15012 *obj = NULL;
15013 }
15014out:
15015 error_propagate(errp, err);
15016}
15017
15018void visit_type_VncVencryptSubAuth(Visitor *v, const char *name, VncVencryptSubAuth *obj, Error **errp)
15019{
15020 int value = *obj;
15021 visit_type_enum(v, name, &value, VncVencryptSubAuth_lookup, errp);
15022 *obj = value;
15023}
15024
15025void visit_type_VsockSocketAddress_members(Visitor *v, VsockSocketAddress *obj, Error **errp)
15026{
15027 Error *err = NULL;
15028
15029 visit_type_str(v, "cid", &obj->cid, &err);
15030 if (err) {
15031 goto out;
15032 }
15033 visit_type_str(v, "port", &obj->port, &err);
15034 if (err) {
15035 goto out;
15036 }
15037
15038out:
15039 error_propagate(errp, err);
15040}
15041
15042void visit_type_VsockSocketAddress(Visitor *v, const char *name, VsockSocketAddress **obj, Error **errp)
15043{
15044 Error *err = NULL;
15045
15046 visit_start_struct(v, name, (void **)obj, sizeof(VsockSocketAddress), &err);
15047 if (err) {
15048 goto out;
15049 }
15050 if (!*obj) {
15051 goto out_obj;
15052 }
15053 visit_type_VsockSocketAddress_members(v, *obj, &err);
15054 if (err) {
15055 goto out_obj;
15056 }
15057 visit_check_struct(v, &err);
15058out_obj:
15059 visit_end_struct(v, (void **)obj);
15060 if (err && visit_is_input(v)) {
15061 qapi_free_VsockSocketAddress(*obj);
15062 *obj = NULL;
15063 }
15064out:
15065 error_propagate(errp, err);
15066}
15067
15068void visit_type_WatchdogExpirationAction(Visitor *v, const char *name, WatchdogExpirationAction *obj, Error **errp)
15069{
15070 int value = *obj;
15071 visit_type_enum(v, name, &value, WatchdogExpirationAction_lookup, errp);
15072 *obj = value;
15073}
15074
15075void visit_type_X86CPUFeatureWordInfo_members(Visitor *v, X86CPUFeatureWordInfo *obj, Error **errp)
15076{
15077 Error *err = NULL;
15078
15079 visit_type_int(v, "cpuid-input-eax", &obj->cpuid_input_eax, &err);
15080 if (err) {
15081 goto out;
15082 }
15083 if (visit_optional(v, "cpuid-input-ecx", &obj->has_cpuid_input_ecx)) {
15084 visit_type_int(v, "cpuid-input-ecx", &obj->cpuid_input_ecx, &err);
15085 if (err) {
15086 goto out;
15087 }
15088 }
15089 visit_type_X86CPURegister32(v, "cpuid-register", &obj->cpuid_register, &err);
15090 if (err) {
15091 goto out;
15092 }
15093 visit_type_int(v, "features", &obj->features, &err);
15094 if (err) {
15095 goto out;
15096 }
15097
15098out:
15099 error_propagate(errp, err);
15100}
15101
15102void visit_type_X86CPUFeatureWordInfo(Visitor *v, const char *name, X86CPUFeatureWordInfo **obj, Error **errp)
15103{
15104 Error *err = NULL;
15105
15106 visit_start_struct(v, name, (void **)obj, sizeof(X86CPUFeatureWordInfo), &err);
15107 if (err) {
15108 goto out;
15109 }
15110 if (!*obj) {
15111 goto out_obj;
15112 }
15113 visit_type_X86CPUFeatureWordInfo_members(v, *obj, &err);
15114 if (err) {
15115 goto out_obj;
15116 }
15117 visit_check_struct(v, &err);
15118out_obj:
15119 visit_end_struct(v, (void **)obj);
15120 if (err && visit_is_input(v)) {
15121 qapi_free_X86CPUFeatureWordInfo(*obj);
15122 *obj = NULL;
15123 }
15124out:
15125 error_propagate(errp, err);
15126}
15127
15128void visit_type_X86CPUFeatureWordInfoList(Visitor *v, const char *name, X86CPUFeatureWordInfoList **obj, Error **errp)
15129{
15130 Error *err = NULL;
15131 X86CPUFeatureWordInfoList *tail;
15132 size_t size = sizeof(**obj);
15133
15134 visit_start_list(v, name, (GenericList **)obj, size, &err);
15135 if (err) {
15136 goto out;
15137 }
15138
15139 for (tail = *obj; tail;
15140 tail = (X86CPUFeatureWordInfoList *)visit_next_list(v, (GenericList *)tail, size)) {
15141 visit_type_X86CPUFeatureWordInfo(v, NULL, &tail->value, &err);
15142 if (err) {
15143 break;
15144 }
15145 }
15146
15147 if (!err) {
15148 visit_check_list(v, &err);
15149 }
15150 visit_end_list(v, (void **)obj);
15151 if (err && visit_is_input(v)) {
15152 qapi_free_X86CPUFeatureWordInfoList(*obj);
15153 *obj = NULL;
15154 }
15155out:
15156 error_propagate(errp, err);
15157}
15158
15159void visit_type_X86CPURegister32(Visitor *v, const char *name, X86CPURegister32 *obj, Error **errp)
15160{
15161 int value = *obj;
15162 visit_type_enum(v, name, &value, X86CPURegister32_lookup, errp);
15163 *obj = value;
15164}
15165
15166void visit_type_XBZRLECacheStats_members(Visitor *v, XBZRLECacheStats *obj, Error **errp)
15167{
15168 Error *err = NULL;
15169
15170 visit_type_int(v, "cache-size", &obj->cache_size, &err);
15171 if (err) {
15172 goto out;
15173 }
15174 visit_type_int(v, "bytes", &obj->bytes, &err);
15175 if (err) {
15176 goto out;
15177 }
15178 visit_type_int(v, "pages", &obj->pages, &err);
15179 if (err) {
15180 goto out;
15181 }
15182 visit_type_int(v, "cache-miss", &obj->cache_miss, &err);
15183 if (err) {
15184 goto out;
15185 }
15186 visit_type_number(v, "cache-miss-rate", &obj->cache_miss_rate, &err);
15187 if (err) {
15188 goto out;
15189 }
15190 visit_type_int(v, "overflow", &obj->overflow, &err);
15191 if (err) {
15192 goto out;
15193 }
15194
15195out:
15196 error_propagate(errp, err);
15197}
15198
15199void visit_type_XBZRLECacheStats(Visitor *v, const char *name, XBZRLECacheStats **obj, Error **errp)
15200{
15201 Error *err = NULL;
15202
15203 visit_start_struct(v, name, (void **)obj, sizeof(XBZRLECacheStats), &err);
15204 if (err) {
15205 goto out;
15206 }
15207 if (!*obj) {
15208 goto out_obj;
15209 }
15210 visit_type_XBZRLECacheStats_members(v, *obj, &err);
15211 if (err) {
15212 goto out_obj;
15213 }
15214 visit_check_struct(v, &err);
15215out_obj:
15216 visit_end_struct(v, (void **)obj);
15217 if (err && visit_is_input(v)) {
15218 qapi_free_XBZRLECacheStats(*obj);
15219 *obj = NULL;
15220 }
15221out:
15222 error_propagate(errp, err);
15223}
15224
15225void visit_type_anyList(Visitor *v, const char *name, anyList **obj, Error **errp)
15226{
15227 Error *err = NULL;
15228 anyList *tail;
15229 size_t size = sizeof(**obj);
15230
15231 visit_start_list(v, name, (GenericList **)obj, size, &err);
15232 if (err) {
15233 goto out;
15234 }
15235
15236 for (tail = *obj; tail;
15237 tail = (anyList *)visit_next_list(v, (GenericList *)tail, size)) {
15238 visit_type_any(v, NULL, &tail->value, &err);
15239 if (err) {
15240 break;
15241 }
15242 }
15243
15244 if (!err) {
15245 visit_check_list(v, &err);
15246 }
15247 visit_end_list(v, (void **)obj);
15248 if (err && visit_is_input(v)) {
15249 qapi_free_anyList(*obj);
15250 *obj = NULL;
15251 }
15252out:
15253 error_propagate(errp, err);
15254}
15255
15256void visit_type_boolList(Visitor *v, const char *name, boolList **obj, Error **errp)
15257{
15258 Error *err = NULL;
15259 boolList *tail;
15260 size_t size = sizeof(**obj);
15261
15262 visit_start_list(v, name, (GenericList **)obj, size, &err);
15263 if (err) {
15264 goto out;
15265 }
15266
15267 for (tail = *obj; tail;
15268 tail = (boolList *)visit_next_list(v, (GenericList *)tail, size)) {
15269 visit_type_bool(v, NULL, &tail->value, &err);
15270 if (err) {
15271 break;
15272 }
15273 }
15274
15275 if (!err) {
15276 visit_check_list(v, &err);
15277 }
15278 visit_end_list(v, (void **)obj);
15279 if (err && visit_is_input(v)) {
15280 qapi_free_boolList(*obj);
15281 *obj = NULL;
15282 }
15283out:
15284 error_propagate(errp, err);
15285}
15286
15287void visit_type_int16List(Visitor *v, const char *name, int16List **obj, Error **errp)
15288{
15289 Error *err = NULL;
15290 int16List *tail;
15291 size_t size = sizeof(**obj);
15292
15293 visit_start_list(v, name, (GenericList **)obj, size, &err);
15294 if (err) {
15295 goto out;
15296 }
15297
15298 for (tail = *obj; tail;
15299 tail = (int16List *)visit_next_list(v, (GenericList *)tail, size)) {
15300 visit_type_int16(v, NULL, &tail->value, &err);
15301 if (err) {
15302 break;
15303 }
15304 }
15305
15306 if (!err) {
15307 visit_check_list(v, &err);
15308 }
15309 visit_end_list(v, (void **)obj);
15310 if (err && visit_is_input(v)) {
15311 qapi_free_int16List(*obj);
15312 *obj = NULL;
15313 }
15314out:
15315 error_propagate(errp, err);
15316}
15317
15318void visit_type_int32List(Visitor *v, const char *name, int32List **obj, Error **errp)
15319{
15320 Error *err = NULL;
15321 int32List *tail;
15322 size_t size = sizeof(**obj);
15323
15324 visit_start_list(v, name, (GenericList **)obj, size, &err);
15325 if (err) {
15326 goto out;
15327 }
15328
15329 for (tail = *obj; tail;
15330 tail = (int32List *)visit_next_list(v, (GenericList *)tail, size)) {
15331 visit_type_int32(v, NULL, &tail->value, &err);
15332 if (err) {
15333 break;
15334 }
15335 }
15336
15337 if (!err) {
15338 visit_check_list(v, &err);
15339 }
15340 visit_end_list(v, (void **)obj);
15341 if (err && visit_is_input(v)) {
15342 qapi_free_int32List(*obj);
15343 *obj = NULL;
15344 }
15345out:
15346 error_propagate(errp, err);
15347}
15348
15349void visit_type_int64List(Visitor *v, const char *name, int64List **obj, Error **errp)
15350{
15351 Error *err = NULL;
15352 int64List *tail;
15353 size_t size = sizeof(**obj);
15354
15355 visit_start_list(v, name, (GenericList **)obj, size, &err);
15356 if (err) {
15357 goto out;
15358 }
15359
15360 for (tail = *obj; tail;
15361 tail = (int64List *)visit_next_list(v, (GenericList *)tail, size)) {
15362 visit_type_int64(v, NULL, &tail->value, &err);
15363 if (err) {
15364 break;
15365 }
15366 }
15367
15368 if (!err) {
15369 visit_check_list(v, &err);
15370 }
15371 visit_end_list(v, (void **)obj);
15372 if (err && visit_is_input(v)) {
15373 qapi_free_int64List(*obj);
15374 *obj = NULL;
15375 }
15376out:
15377 error_propagate(errp, err);
15378}
15379
15380void visit_type_int8List(Visitor *v, const char *name, int8List **obj, Error **errp)
15381{
15382 Error *err = NULL;
15383 int8List *tail;
15384 size_t size = sizeof(**obj);
15385
15386 visit_start_list(v, name, (GenericList **)obj, size, &err);
15387 if (err) {
15388 goto out;
15389 }
15390
15391 for (tail = *obj; tail;
15392 tail = (int8List *)visit_next_list(v, (GenericList *)tail, size)) {
15393 visit_type_int8(v, NULL, &tail->value, &err);
15394 if (err) {
15395 break;
15396 }
15397 }
15398
15399 if (!err) {
15400 visit_check_list(v, &err);
15401 }
15402 visit_end_list(v, (void **)obj);
15403 if (err && visit_is_input(v)) {
15404 qapi_free_int8List(*obj);
15405 *obj = NULL;
15406 }
15407out:
15408 error_propagate(errp, err);
15409}
15410
15411void visit_type_intList(Visitor *v, const char *name, intList **obj, Error **errp)
15412{
15413 Error *err = NULL;
15414 intList *tail;
15415 size_t size = sizeof(**obj);
15416
15417 visit_start_list(v, name, (GenericList **)obj, size, &err);
15418 if (err) {
15419 goto out;
15420 }
15421
15422 for (tail = *obj; tail;
15423 tail = (intList *)visit_next_list(v, (GenericList *)tail, size)) {
15424 visit_type_int(v, NULL, &tail->value, &err);
15425 if (err) {
15426 break;
15427 }
15428 }
15429
15430 if (!err) {
15431 visit_check_list(v, &err);
15432 }
15433 visit_end_list(v, (void **)obj);
15434 if (err && visit_is_input(v)) {
15435 qapi_free_intList(*obj);
15436 *obj = NULL;
15437 }
15438out:
15439 error_propagate(errp, err);
15440}
15441
15442void visit_type_nullList(Visitor *v, const char *name, nullList **obj, Error **errp)
15443{
15444 Error *err = NULL;
15445 nullList *tail;
15446 size_t size = sizeof(**obj);
15447
15448 visit_start_list(v, name, (GenericList **)obj, size, &err);
15449 if (err) {
15450 goto out;
15451 }
15452
15453 for (tail = *obj; tail;
15454 tail = (nullList *)visit_next_list(v, (GenericList *)tail, size)) {
15455 visit_type_null(v, NULL, &tail->value, &err);
15456 if (err) {
15457 break;
15458 }
15459 }
15460
15461 if (!err) {
15462 visit_check_list(v, &err);
15463 }
15464 visit_end_list(v, (void **)obj);
15465 if (err && visit_is_input(v)) {
15466 qapi_free_nullList(*obj);
15467 *obj = NULL;
15468 }
15469out:
15470 error_propagate(errp, err);
15471}
15472
15473void visit_type_numberList(Visitor *v, const char *name, numberList **obj, Error **errp)
15474{
15475 Error *err = NULL;
15476 numberList *tail;
15477 size_t size = sizeof(**obj);
15478
15479 visit_start_list(v, name, (GenericList **)obj, size, &err);
15480 if (err) {
15481 goto out;
15482 }
15483
15484 for (tail = *obj; tail;
15485 tail = (numberList *)visit_next_list(v, (GenericList *)tail, size)) {
15486 visit_type_number(v, NULL, &tail->value, &err);
15487 if (err) {
15488 break;
15489 }
15490 }
15491
15492 if (!err) {
15493 visit_check_list(v, &err);
15494 }
15495 visit_end_list(v, (void **)obj);
15496 if (err && visit_is_input(v)) {
15497 qapi_free_numberList(*obj);
15498 *obj = NULL;
15499 }
15500out:
15501 error_propagate(errp, err);
15502}
15503
15504void visit_type_q_obj_ACPI_DEVICE_OST_arg_members(Visitor *v, q_obj_ACPI_DEVICE_OST_arg *obj, Error **errp)
15505{
15506 Error *err = NULL;
15507
15508 visit_type_ACPIOSTInfo(v, "info", &obj->info, &err);
15509 if (err) {
15510 goto out;
15511 }
15512
15513out:
15514 error_propagate(errp, err);
15515}
15516
15517void visit_type_q_obj_Abort_wrapper_members(Visitor *v, q_obj_Abort_wrapper *obj, Error **errp)
15518{
15519 Error *err = NULL;
15520
15521 visit_type_Abort(v, "data", &obj->data, &err);
15522 if (err) {
15523 goto out;
15524 }
15525
15526out:
15527 error_propagate(errp, err);
15528}
15529
15530void visit_type_q_obj_BALLOON_CHANGE_arg_members(Visitor *v, q_obj_BALLOON_CHANGE_arg *obj, Error **errp)
15531{
15532 Error *err = NULL;
15533
15534 visit_type_int(v, "actual", &obj->actual, &err);
15535 if (err) {
15536 goto out;
15537 }
15538
15539out:
15540 error_propagate(errp, err);
15541}
15542
15543void visit_type_q_obj_BLOCK_IMAGE_CORRUPTED_arg_members(Visitor *v, q_obj_BLOCK_IMAGE_CORRUPTED_arg *obj, Error **errp)
15544{
15545 Error *err = NULL;
15546
15547 visit_type_str(v, "device", &obj->device, &err);
15548 if (err) {
15549 goto out;
15550 }
15551 if (visit_optional(v, "node-name", &obj->has_node_name)) {
15552 visit_type_str(v, "node-name", &obj->node_name, &err);
15553 if (err) {
15554 goto out;
15555 }
15556 }
15557 visit_type_str(v, "msg", &obj->msg, &err);
15558 if (err) {
15559 goto out;
15560 }
15561 if (visit_optional(v, "offset", &obj->has_offset)) {
15562 visit_type_int(v, "offset", &obj->offset, &err);
15563 if (err) {
15564 goto out;
15565 }
15566 }
15567 if (visit_optional(v, "size", &obj->has_size)) {
15568 visit_type_int(v, "size", &obj->size, &err);
15569 if (err) {
15570 goto out;
15571 }
15572 }
15573 visit_type_bool(v, "fatal", &obj->fatal, &err);
15574 if (err) {
15575 goto out;
15576 }
15577
15578out:
15579 error_propagate(errp, err);
15580}
15581
15582void visit_type_q_obj_BLOCK_IO_ERROR_arg_members(Visitor *v, q_obj_BLOCK_IO_ERROR_arg *obj, Error **errp)
15583{
15584 Error *err = NULL;
15585
15586 visit_type_str(v, "device", &obj->device, &err);
15587 if (err) {
15588 goto out;
15589 }
15590 visit_type_str(v, "node-name", &obj->node_name, &err);
15591 if (err) {
15592 goto out;
15593 }
15594 visit_type_IoOperationType(v, "operation", &obj->operation, &err);
15595 if (err) {
15596 goto out;
15597 }
15598 visit_type_BlockErrorAction(v, "action", &obj->action, &err);
15599 if (err) {
15600 goto out;
15601 }
15602 if (visit_optional(v, "nospace", &obj->has_nospace)) {
15603 visit_type_bool(v, "nospace", &obj->nospace, &err);
15604 if (err) {
15605 goto out;
15606 }
15607 }
15608 visit_type_str(v, "reason", &obj->reason, &err);
15609 if (err) {
15610 goto out;
15611 }
15612
15613out:
15614 error_propagate(errp, err);
15615}
15616
15617void visit_type_q_obj_BLOCK_JOB_CANCELLED_arg_members(Visitor *v, q_obj_BLOCK_JOB_CANCELLED_arg *obj, Error **errp)
15618{
15619 Error *err = NULL;
15620
15621 visit_type_BlockJobType(v, "type", &obj->type, &err);
15622 if (err) {
15623 goto out;
15624 }
15625 visit_type_str(v, "device", &obj->device, &err);
15626 if (err) {
15627 goto out;
15628 }
15629 visit_type_int(v, "len", &obj->len, &err);
15630 if (err) {
15631 goto out;
15632 }
15633 visit_type_int(v, "offset", &obj->offset, &err);
15634 if (err) {
15635 goto out;
15636 }
15637 visit_type_int(v, "speed", &obj->speed, &err);
15638 if (err) {
15639 goto out;
15640 }
15641
15642out:
15643 error_propagate(errp, err);
15644}
15645
15646void visit_type_q_obj_BLOCK_JOB_COMPLETED_arg_members(Visitor *v, q_obj_BLOCK_JOB_COMPLETED_arg *obj, Error **errp)
15647{
15648 Error *err = NULL;
15649
15650 visit_type_BlockJobType(v, "type", &obj->type, &err);
15651 if (err) {
15652 goto out;
15653 }
15654 visit_type_str(v, "device", &obj->device, &err);
15655 if (err) {
15656 goto out;
15657 }
15658 visit_type_int(v, "len", &obj->len, &err);
15659 if (err) {
15660 goto out;
15661 }
15662 visit_type_int(v, "offset", &obj->offset, &err);
15663 if (err) {
15664 goto out;
15665 }
15666 visit_type_int(v, "speed", &obj->speed, &err);
15667 if (err) {
15668 goto out;
15669 }
15670 if (visit_optional(v, "error", &obj->has_error)) {
15671 visit_type_str(v, "error", &obj->error, &err);
15672 if (err) {
15673 goto out;
15674 }
15675 }
15676
15677out:
15678 error_propagate(errp, err);
15679}
15680
15681void visit_type_q_obj_BLOCK_JOB_ERROR_arg_members(Visitor *v, q_obj_BLOCK_JOB_ERROR_arg *obj, Error **errp)
15682{
15683 Error *err = NULL;
15684
15685 visit_type_str(v, "device", &obj->device, &err);
15686 if (err) {
15687 goto out;
15688 }
15689 visit_type_IoOperationType(v, "operation", &obj->operation, &err);
15690 if (err) {
15691 goto out;
15692 }
15693 visit_type_BlockErrorAction(v, "action", &obj->action, &err);
15694 if (err) {
15695 goto out;
15696 }
15697
15698out:
15699 error_propagate(errp, err);
15700}
15701
15702void visit_type_q_obj_BLOCK_JOB_READY_arg_members(Visitor *v, q_obj_BLOCK_JOB_READY_arg *obj, Error **errp)
15703{
15704 Error *err = NULL;
15705
15706 visit_type_BlockJobType(v, "type", &obj->type, &err);
15707 if (err) {
15708 goto out;
15709 }
15710 visit_type_str(v, "device", &obj->device, &err);
15711 if (err) {
15712 goto out;
15713 }
15714 visit_type_int(v, "len", &obj->len, &err);
15715 if (err) {
15716 goto out;
15717 }
15718 visit_type_int(v, "offset", &obj->offset, &err);
15719 if (err) {
15720 goto out;
15721 }
15722 visit_type_int(v, "speed", &obj->speed, &err);
15723 if (err) {
15724 goto out;
15725 }
15726
15727out:
15728 error_propagate(errp, err);
15729}
15730
15731void visit_type_q_obj_BLOCK_WRITE_THRESHOLD_arg_members(Visitor *v, q_obj_BLOCK_WRITE_THRESHOLD_arg *obj, Error **errp)
15732{
15733 Error *err = NULL;
15734
15735 visit_type_str(v, "node-name", &obj->node_name, &err);
15736 if (err) {
15737 goto out;
15738 }
15739 visit_type_uint64(v, "amount-exceeded", &obj->amount_exceeded, &err);
15740 if (err) {
15741 goto out;
15742 }
15743 visit_type_uint64(v, "write-threshold", &obj->write_threshold, &err);
15744 if (err) {
15745 goto out;
15746 }
15747
15748out:
15749 error_propagate(errp, err);
15750}
15751
15752void visit_type_q_obj_BlockDirtyBitmap_wrapper_members(Visitor *v, q_obj_BlockDirtyBitmap_wrapper *obj, Error **errp)
15753{
15754 Error *err = NULL;
15755
15756 visit_type_BlockDirtyBitmap(v, "data", &obj->data, &err);
15757 if (err) {
15758 goto out;
15759 }
15760
15761out:
15762 error_propagate(errp, err);
15763}
15764
15765void visit_type_q_obj_BlockDirtyBitmapAdd_wrapper_members(Visitor *v, q_obj_BlockDirtyBitmapAdd_wrapper *obj, Error **errp)
15766{
15767 Error *err = NULL;
15768
15769 visit_type_BlockDirtyBitmapAdd(v, "data", &obj->data, &err);
15770 if (err) {
15771 goto out;
15772 }
15773
15774out:
15775 error_propagate(errp, err);
15776}
15777
15778void visit_type_q_obj_BlockdevBackup_wrapper_members(Visitor *v, q_obj_BlockdevBackup_wrapper *obj, Error **errp)
15779{
15780 Error *err = NULL;
15781
15782 visit_type_BlockdevBackup(v, "data", &obj->data, &err);
15783 if (err) {
15784 goto out;
15785 }
15786
15787out:
15788 error_propagate(errp, err);
15789}
15790
15791void visit_type_q_obj_BlockdevOptions_base_members(Visitor *v, q_obj_BlockdevOptions_base *obj, Error **errp)
15792{
15793 Error *err = NULL;
15794
15795 visit_type_BlockdevDriver(v, "driver", &obj->driver, &err);
15796 if (err) {
15797 goto out;
15798 }
15799 if (visit_optional(v, "node-name", &obj->has_node_name)) {
15800 visit_type_str(v, "node-name", &obj->node_name, &err);
15801 if (err) {
15802 goto out;
15803 }
15804 }
15805 if (visit_optional(v, "discard", &obj->has_discard)) {
15806 visit_type_BlockdevDiscardOptions(v, "discard", &obj->discard, &err);
15807 if (err) {
15808 goto out;
15809 }
15810 }
15811 if (visit_optional(v, "cache", &obj->has_cache)) {
15812 visit_type_BlockdevCacheOptions(v, "cache", &obj->cache, &err);
15813 if (err) {
15814 goto out;
15815 }
15816 }
15817 if (visit_optional(v, "read-only", &obj->has_read_only)) {
15818 visit_type_bool(v, "read-only", &obj->read_only, &err);
15819 if (err) {
15820 goto out;
15821 }
15822 }
15823 if (visit_optional(v, "force-share", &obj->has_force_share)) {
15824 visit_type_bool(v, "force-share", &obj->force_share, &err);
15825 if (err) {
15826 goto out;
15827 }
15828 }
15829 if (visit_optional(v, "detect-zeroes", &obj->has_detect_zeroes)) {
15830 visit_type_BlockdevDetectZeroesOptions(v, "detect-zeroes", &obj->detect_zeroes, &err);
15831 if (err) {
15832 goto out;
15833 }
15834 }
15835
15836out:
15837 error_propagate(errp, err);
15838}
15839
15840void visit_type_q_obj_BlockdevQcow2Encryption_base_members(Visitor *v, q_obj_BlockdevQcow2Encryption_base *obj, Error **errp)
15841{
15842 Error *err = NULL;
15843
15844 visit_type_BlockdevQcow2EncryptionFormat(v, "format", &obj->format, &err);
15845 if (err) {
15846 goto out;
15847 }
15848
15849out:
15850 error_propagate(errp, err);
15851}
15852
15853void visit_type_q_obj_BlockdevQcowEncryption_base_members(Visitor *v, q_obj_BlockdevQcowEncryption_base *obj, Error **errp)
15854{
15855 Error *err = NULL;
15856
15857 visit_type_BlockdevQcowEncryptionFormat(v, "format", &obj->format, &err);
15858 if (err) {
15859 goto out;
15860 }
15861
15862out:
15863 error_propagate(errp, err);
15864}
15865
15866void visit_type_q_obj_BlockdevSnapshot_wrapper_members(Visitor *v, q_obj_BlockdevSnapshot_wrapper *obj, Error **errp)
15867{
15868 Error *err = NULL;
15869
15870 visit_type_BlockdevSnapshot(v, "data", &obj->data, &err);
15871 if (err) {
15872 goto out;
15873 }
15874
15875out:
15876 error_propagate(errp, err);
15877}
15878
15879void visit_type_q_obj_BlockdevSnapshotInternal_wrapper_members(Visitor *v, q_obj_BlockdevSnapshotInternal_wrapper *obj, Error **errp)
15880{
15881 Error *err = NULL;
15882
15883 visit_type_BlockdevSnapshotInternal(v, "data", &obj->data, &err);
15884 if (err) {
15885 goto out;
15886 }
15887
15888out:
15889 error_propagate(errp, err);
15890}
15891
15892void visit_type_q_obj_BlockdevSnapshotSync_wrapper_members(Visitor *v, q_obj_BlockdevSnapshotSync_wrapper *obj, Error **errp)
15893{
15894 Error *err = NULL;
15895
15896 visit_type_BlockdevSnapshotSync(v, "data", &obj->data, &err);
15897 if (err) {
15898 goto out;
15899 }
15900
15901out:
15902 error_propagate(errp, err);
15903}
15904
15905void visit_type_q_obj_ChardevCommon_wrapper_members(Visitor *v, q_obj_ChardevCommon_wrapper *obj, Error **errp)
15906{
15907 Error *err = NULL;
15908
15909 visit_type_ChardevCommon(v, "data", &obj->data, &err);
15910 if (err) {
15911 goto out;
15912 }
15913
15914out:
15915 error_propagate(errp, err);
15916}
15917
15918void visit_type_q_obj_ChardevFile_wrapper_members(Visitor *v, q_obj_ChardevFile_wrapper *obj, Error **errp)
15919{
15920 Error *err = NULL;
15921
15922 visit_type_ChardevFile(v, "data", &obj->data, &err);
15923 if (err) {
15924 goto out;
15925 }
15926
15927out:
15928 error_propagate(errp, err);
15929}
15930
15931void visit_type_q_obj_ChardevHostdev_wrapper_members(Visitor *v, q_obj_ChardevHostdev_wrapper *obj, Error **errp)
15932{
15933 Error *err = NULL;
15934
15935 visit_type_ChardevHostdev(v, "data", &obj->data, &err);
15936 if (err) {
15937 goto out;
15938 }
15939
15940out:
15941 error_propagate(errp, err);
15942}
15943
15944void visit_type_q_obj_ChardevMux_wrapper_members(Visitor *v, q_obj_ChardevMux_wrapper *obj, Error **errp)
15945{
15946 Error *err = NULL;
15947
15948 visit_type_ChardevMux(v, "data", &obj->data, &err);
15949 if (err) {
15950 goto out;
15951 }
15952
15953out:
15954 error_propagate(errp, err);
15955}
15956
15957void visit_type_q_obj_ChardevRingbuf_wrapper_members(Visitor *v, q_obj_ChardevRingbuf_wrapper *obj, Error **errp)
15958{
15959 Error *err = NULL;
15960
15961 visit_type_ChardevRingbuf(v, "data", &obj->data, &err);
15962 if (err) {
15963 goto out;
15964 }
15965
15966out:
15967 error_propagate(errp, err);
15968}
15969
15970void visit_type_q_obj_ChardevSocket_wrapper_members(Visitor *v, q_obj_ChardevSocket_wrapper *obj, Error **errp)
15971{
15972 Error *err = NULL;
15973
15974 visit_type_ChardevSocket(v, "data", &obj->data, &err);
15975 if (err) {
15976 goto out;
15977 }
15978
15979out:
15980 error_propagate(errp, err);
15981}
15982
15983void visit_type_q_obj_ChardevSpiceChannel_wrapper_members(Visitor *v, q_obj_ChardevSpiceChannel_wrapper *obj, Error **errp)
15984{
15985 Error *err = NULL;
15986
15987 visit_type_ChardevSpiceChannel(v, "data", &obj->data, &err);
15988 if (err) {
15989 goto out;
15990 }
15991
15992out:
15993 error_propagate(errp, err);
15994}
15995
15996void visit_type_q_obj_ChardevSpicePort_wrapper_members(Visitor *v, q_obj_ChardevSpicePort_wrapper *obj, Error **errp)
15997{
15998 Error *err = NULL;
15999
16000 visit_type_ChardevSpicePort(v, "data", &obj->data, &err);
16001 if (err) {
16002 goto out;
16003 }
16004
16005out:
16006 error_propagate(errp, err);
16007}
16008
16009void visit_type_q_obj_ChardevStdio_wrapper_members(Visitor *v, q_obj_ChardevStdio_wrapper *obj, Error **errp)
16010{
16011 Error *err = NULL;
16012
16013 visit_type_ChardevStdio(v, "data", &obj->data, &err);
16014 if (err) {
16015 goto out;
16016 }
16017
16018out:
16019 error_propagate(errp, err);
16020}
16021
16022void visit_type_q_obj_ChardevUdp_wrapper_members(Visitor *v, q_obj_ChardevUdp_wrapper *obj, Error **errp)
16023{
16024 Error *err = NULL;
16025
16026 visit_type_ChardevUdp(v, "data", &obj->data, &err);
16027 if (err) {
16028 goto out;
16029 }
16030
16031out:
16032 error_propagate(errp, err);
16033}
16034
16035void visit_type_q_obj_ChardevVC_wrapper_members(Visitor *v, q_obj_ChardevVC_wrapper *obj, Error **errp)
16036{
16037 Error *err = NULL;
16038
16039 visit_type_ChardevVC(v, "data", &obj->data, &err);
16040 if (err) {
16041 goto out;
16042 }
16043
16044out:
16045 error_propagate(errp, err);
16046}
16047
16048void visit_type_q_obj_CpuInfo_base_members(Visitor *v, q_obj_CpuInfo_base *obj, Error **errp)
16049{
16050 Error *err = NULL;
16051
16052 visit_type_int(v, "CPU", &obj->CPU, &err);
16053 if (err) {
16054 goto out;
16055 }
16056 visit_type_bool(v, "current", &obj->current, &err);
16057 if (err) {
16058 goto out;
16059 }
16060 visit_type_bool(v, "halted", &obj->halted, &err);
16061 if (err) {
16062 goto out;
16063 }
16064 visit_type_str(v, "qom_path", &obj->qom_path, &err);
16065 if (err) {
16066 goto out;
16067 }
16068 visit_type_int(v, "thread_id", &obj->thread_id, &err);
16069 if (err) {
16070 goto out;
16071 }
16072 if (visit_optional(v, "props", &obj->has_props)) {
16073 visit_type_CpuInstanceProperties(v, "props", &obj->props, &err);
16074 if (err) {
16075 goto out;
16076 }
16077 }
16078 visit_type_CpuInfoArch(v, "arch", &obj->arch, &err);
16079 if (err) {
16080 goto out;
16081 }
16082
16083out:
16084 error_propagate(errp, err);
16085}
16086
16087void visit_type_q_obj_DEVICE_DELETED_arg_members(Visitor *v, q_obj_DEVICE_DELETED_arg *obj, Error **errp)
16088{
16089 Error *err = NULL;
16090
16091 if (visit_optional(v, "device", &obj->has_device)) {
16092 visit_type_str(v, "device", &obj->device, &err);
16093 if (err) {
16094 goto out;
16095 }
16096 }
16097 visit_type_str(v, "path", &obj->path, &err);
16098 if (err) {
16099 goto out;
16100 }
16101
16102out:
16103 error_propagate(errp, err);
16104}
16105
16106void visit_type_q_obj_DEVICE_TRAY_MOVED_arg_members(Visitor *v, q_obj_DEVICE_TRAY_MOVED_arg *obj, Error **errp)
16107{
16108 Error *err = NULL;
16109
16110 visit_type_str(v, "device", &obj->device, &err);
16111 if (err) {
16112 goto out;
16113 }
16114 visit_type_str(v, "id", &obj->id, &err);
16115 if (err) {
16116 goto out;
16117 }
16118 visit_type_bool(v, "tray-open", &obj->tray_open, &err);
16119 if (err) {
16120 goto out;
16121 }
16122
16123out:
16124 error_propagate(errp, err);
16125}
16126
16127void visit_type_q_obj_DUMP_COMPLETED_arg_members(Visitor *v, q_obj_DUMP_COMPLETED_arg *obj, Error **errp)
16128{
16129 Error *err = NULL;
16130
16131 visit_type_DumpQueryResult(v, "result", &obj->result, &err);
16132 if (err) {
16133 goto out;
16134 }
16135 if (visit_optional(v, "error", &obj->has_error)) {
16136 visit_type_str(v, "error", &obj->error, &err);
16137 if (err) {
16138 goto out;
16139 }
16140 }
16141
16142out:
16143 error_propagate(errp, err);
16144}
16145
16146void visit_type_q_obj_DriveBackup_wrapper_members(Visitor *v, q_obj_DriveBackup_wrapper *obj, Error **errp)
16147{
16148 Error *err = NULL;
16149
16150 visit_type_DriveBackup(v, "data", &obj->data, &err);
16151 if (err) {
16152 goto out;
16153 }
16154
16155out:
16156 error_propagate(errp, err);
16157}
16158
16159void visit_type_q_obj_GUEST_PANICKED_arg_members(Visitor *v, q_obj_GUEST_PANICKED_arg *obj, Error **errp)
16160{
16161 Error *err = NULL;
16162
16163 visit_type_GuestPanicAction(v, "action", &obj->action, &err);
16164 if (err) {
16165 goto out;
16166 }
16167 if (visit_optional(v, "info", &obj->has_info)) {
16168 visit_type_GuestPanicInformation(v, "info", &obj->info, &err);
16169 if (err) {
16170 goto out;
16171 }
16172 }
16173
16174out:
16175 error_propagate(errp, err);
16176}
16177
16178void visit_type_q_obj_GuestPanicInformation_base_members(Visitor *v, q_obj_GuestPanicInformation_base *obj, Error **errp)
16179{
16180 Error *err = NULL;
16181
16182 visit_type_GuestPanicInformationType(v, "type", &obj->type, &err);
16183 if (err) {
16184 goto out;
16185 }
16186
16187out:
16188 error_propagate(errp, err);
16189}
16190
16191void visit_type_q_obj_ImageInfoSpecificQCow2_wrapper_members(Visitor *v, q_obj_ImageInfoSpecificQCow2_wrapper *obj, Error **errp)
16192{
16193 Error *err = NULL;
16194
16195 visit_type_ImageInfoSpecificQCow2(v, "data", &obj->data, &err);
16196 if (err) {
16197 goto out;
16198 }
16199
16200out:
16201 error_propagate(errp, err);
16202}
16203
16204void visit_type_q_obj_ImageInfoSpecificVmdk_wrapper_members(Visitor *v, q_obj_ImageInfoSpecificVmdk_wrapper *obj, Error **errp)
16205{
16206 Error *err = NULL;
16207
16208 visit_type_ImageInfoSpecificVmdk(v, "data", &obj->data, &err);
16209 if (err) {
16210 goto out;
16211 }
16212
16213out:
16214 error_propagate(errp, err);
16215}
16216
16217void visit_type_q_obj_InetSocketAddress_wrapper_members(Visitor *v, q_obj_InetSocketAddress_wrapper *obj, Error **errp)
16218{
16219 Error *err = NULL;
16220
16221 visit_type_InetSocketAddress(v, "data", &obj->data, &err);
16222 if (err) {
16223 goto out;
16224 }
16225
16226out:
16227 error_propagate(errp, err);
16228}
16229
16230void visit_type_q_obj_InputBtnEvent_wrapper_members(Visitor *v, q_obj_InputBtnEvent_wrapper *obj, Error **errp)
16231{
16232 Error *err = NULL;
16233
16234 visit_type_InputBtnEvent(v, "data", &obj->data, &err);
16235 if (err) {
16236 goto out;
16237 }
16238
16239out:
16240 error_propagate(errp, err);
16241}
16242
16243void visit_type_q_obj_InputKeyEvent_wrapper_members(Visitor *v, q_obj_InputKeyEvent_wrapper *obj, Error **errp)
16244{
16245 Error *err = NULL;
16246
16247 visit_type_InputKeyEvent(v, "data", &obj->data, &err);
16248 if (err) {
16249 goto out;
16250 }
16251
16252out:
16253 error_propagate(errp, err);
16254}
16255
16256void visit_type_q_obj_InputMoveEvent_wrapper_members(Visitor *v, q_obj_InputMoveEvent_wrapper *obj, Error **errp)
16257{
16258 Error *err = NULL;
16259
16260 visit_type_InputMoveEvent(v, "data", &obj->data, &err);
16261 if (err) {
16262 goto out;
16263 }
16264
16265out:
16266 error_propagate(errp, err);
16267}
16268
16269void visit_type_q_obj_MEM_UNPLUG_ERROR_arg_members(Visitor *v, q_obj_MEM_UNPLUG_ERROR_arg *obj, Error **errp)
16270{
16271 Error *err = NULL;
16272
16273 visit_type_str(v, "device", &obj->device, &err);
16274 if (err) {
16275 goto out;
16276 }
16277 visit_type_str(v, "msg", &obj->msg, &err);
16278 if (err) {
16279 goto out;
16280 }
16281
16282out:
16283 error_propagate(errp, err);
16284}
16285
16286void visit_type_q_obj_MIGRATION_arg_members(Visitor *v, q_obj_MIGRATION_arg *obj, Error **errp)
16287{
16288 Error *err = NULL;
16289
16290 visit_type_MigrationStatus(v, "status", &obj->status, &err);
16291 if (err) {
16292 goto out;
16293 }
16294
16295out:
16296 error_propagate(errp, err);
16297}
16298
16299void visit_type_q_obj_MIGRATION_PASS_arg_members(Visitor *v, q_obj_MIGRATION_PASS_arg *obj, Error **errp)
16300{
16301 Error *err = NULL;
16302
16303 visit_type_int(v, "pass", &obj->pass, &err);
16304 if (err) {
16305 goto out;
16306 }
16307
16308out:
16309 error_propagate(errp, err);
16310}
16311
16312void visit_type_q_obj_NIC_RX_FILTER_CHANGED_arg_members(Visitor *v, q_obj_NIC_RX_FILTER_CHANGED_arg *obj, Error **errp)
16313{
16314 Error *err = NULL;
16315
16316 if (visit_optional(v, "name", &obj->has_name)) {
16317 visit_type_str(v, "name", &obj->name, &err);
16318 if (err) {
16319 goto out;
16320 }
16321 }
16322 visit_type_str(v, "path", &obj->path, &err);
16323 if (err) {
16324 goto out;
16325 }
16326
16327out:
16328 error_propagate(errp, err);
16329}
16330
16331void visit_type_q_obj_NetLegacyOptions_base_members(Visitor *v, q_obj_NetLegacyOptions_base *obj, Error **errp)
16332{
16333 Error *err = NULL;
16334
16335 visit_type_NetLegacyOptionsType(v, "type", &obj->type, &err);
16336 if (err) {
16337 goto out;
16338 }
16339
16340out:
16341 error_propagate(errp, err);
16342}
16343
16344void visit_type_q_obj_Netdev_base_members(Visitor *v, q_obj_Netdev_base *obj, Error **errp)
16345{
16346 Error *err = NULL;
16347
16348 visit_type_str(v, "id", &obj->id, &err);
16349 if (err) {
16350 goto out;
16351 }
16352 visit_type_NetClientDriver(v, "type", &obj->type, &err);
16353 if (err) {
16354 goto out;
16355 }
16356
16357out:
16358 error_propagate(errp, err);
16359}
16360
16361void visit_type_q_obj_NumaOptions_base_members(Visitor *v, q_obj_NumaOptions_base *obj, Error **errp)
16362{
16363 Error *err = NULL;
16364
16365 visit_type_NumaOptionsType(v, "type", &obj->type, &err);
16366 if (err) {
16367 goto out;
16368 }
16369
16370out:
16371 error_propagate(errp, err);
16372}
16373
16374void visit_type_q_obj_PCDIMMDeviceInfo_wrapper_members(Visitor *v, q_obj_PCDIMMDeviceInfo_wrapper *obj, Error **errp)
16375{
16376 Error *err = NULL;
16377
16378 visit_type_PCDIMMDeviceInfo(v, "data", &obj->data, &err);
16379 if (err) {
16380 goto out;
16381 }
16382
16383out:
16384 error_propagate(errp, err);
16385}
16386
16387void visit_type_q_obj_QCryptoBlockInfoLUKS_wrapper_members(Visitor *v, q_obj_QCryptoBlockInfoLUKS_wrapper *obj, Error **errp)
16388{
16389 Error *err = NULL;
16390
16391 visit_type_QCryptoBlockInfoLUKS(v, "data", &obj->data, &err);
16392 if (err) {
16393 goto out;
16394 }
16395
16396out:
16397 error_propagate(errp, err);
16398}
16399
16400void visit_type_q_obj_QKeyCode_wrapper_members(Visitor *v, q_obj_QKeyCode_wrapper *obj, Error **errp)
16401{
16402 Error *err = NULL;
16403
16404 visit_type_QKeyCode(v, "data", &obj->data, &err);
16405 if (err) {
16406 goto out;
16407 }
16408
16409out:
16410 error_propagate(errp, err);
16411}
16412
16413void visit_type_q_obj_QUORUM_FAILURE_arg_members(Visitor *v, q_obj_QUORUM_FAILURE_arg *obj, Error **errp)
16414{
16415 Error *err = NULL;
16416
16417 visit_type_str(v, "reference", &obj->reference, &err);
16418 if (err) {
16419 goto out;
16420 }
16421 visit_type_int(v, "sector-num", &obj->sector_num, &err);
16422 if (err) {
16423 goto out;
16424 }
16425 visit_type_int(v, "sectors-count", &obj->sectors_count, &err);
16426 if (err) {
16427 goto out;
16428 }
16429
16430out:
16431 error_propagate(errp, err);
16432}
16433
16434void visit_type_q_obj_QUORUM_REPORT_BAD_arg_members(Visitor *v, q_obj_QUORUM_REPORT_BAD_arg *obj, Error **errp)
16435{
16436 Error *err = NULL;
16437
16438 visit_type_QuorumOpType(v, "type", &obj->type, &err);
16439 if (err) {
16440 goto out;
16441 }
16442 if (visit_optional(v, "error", &obj->has_error)) {
16443 visit_type_str(v, "error", &obj->error, &err);
16444 if (err) {
16445 goto out;
16446 }
16447 }
16448 visit_type_str(v, "node-name", &obj->node_name, &err);
16449 if (err) {
16450 goto out;
16451 }
16452 visit_type_int(v, "sector-num", &obj->sector_num, &err);
16453 if (err) {
16454 goto out;
16455 }
16456 visit_type_int(v, "sectors-count", &obj->sectors_count, &err);
16457 if (err) {
16458 goto out;
16459 }
16460
16461out:
16462 error_propagate(errp, err);
16463}
16464
16465void visit_type_q_obj_RESET_arg_members(Visitor *v, q_obj_RESET_arg *obj, Error **errp)
16466{
16467 Error *err = NULL;
16468
16469 visit_type_bool(v, "guest", &obj->guest, &err);
16470 if (err) {
16471 goto out;
16472 }
16473
16474out:
16475 error_propagate(errp, err);
16476}
16477
16478void visit_type_q_obj_RTC_CHANGE_arg_members(Visitor *v, q_obj_RTC_CHANGE_arg *obj, Error **errp)
16479{
16480 Error *err = NULL;
16481
16482 visit_type_int(v, "offset", &obj->offset, &err);
16483 if (err) {
16484 goto out;
16485 }
16486
16487out:
16488 error_propagate(errp, err);
16489}
16490
16491void visit_type_q_obj_SHUTDOWN_arg_members(Visitor *v, q_obj_SHUTDOWN_arg *obj, Error **errp)
16492{
16493 Error *err = NULL;
16494
16495 visit_type_bool(v, "guest", &obj->guest, &err);
16496 if (err) {
16497 goto out;
16498 }
16499
16500out:
16501 error_propagate(errp, err);
16502}
16503
16504void visit_type_q_obj_SPICE_CONNECTED_arg_members(Visitor *v, q_obj_SPICE_CONNECTED_arg *obj, Error **errp)
16505{
16506 Error *err = NULL;
16507
16508 visit_type_SpiceBasicInfo(v, "server", &obj->server, &err);
16509 if (err) {
16510 goto out;
16511 }
16512 visit_type_SpiceBasicInfo(v, "client", &obj->client, &err);
16513 if (err) {
16514 goto out;
16515 }
16516
16517out:
16518 error_propagate(errp, err);
16519}
16520
16521void visit_type_q_obj_SPICE_DISCONNECTED_arg_members(Visitor *v, q_obj_SPICE_DISCONNECTED_arg *obj, Error **errp)
16522{
16523 Error *err = NULL;
16524
16525 visit_type_SpiceBasicInfo(v, "server", &obj->server, &err);
16526 if (err) {
16527 goto out;
16528 }
16529 visit_type_SpiceBasicInfo(v, "client", &obj->client, &err);
16530 if (err) {
16531 goto out;
16532 }
16533
16534out:
16535 error_propagate(errp, err);
16536}
16537
16538void visit_type_q_obj_SPICE_INITIALIZED_arg_members(Visitor *v, q_obj_SPICE_INITIALIZED_arg *obj, Error **errp)
16539{
16540 Error *err = NULL;
16541
16542 visit_type_SpiceServerInfo(v, "server", &obj->server, &err);
16543 if (err) {
16544 goto out;
16545 }
16546 visit_type_SpiceChannel(v, "client", &obj->client, &err);
16547 if (err) {
16548 goto out;
16549 }
16550
16551out:
16552 error_propagate(errp, err);
16553}
16554
16555void visit_type_q_obj_SchemaInfo_base_members(Visitor *v, q_obj_SchemaInfo_base *obj, Error **errp)
16556{
16557 Error *err = NULL;
16558
16559 visit_type_str(v, "name", &obj->name, &err);
16560 if (err) {
16561 goto out;
16562 }
16563 visit_type_SchemaMetaType(v, "meta-type", &obj->meta_type, &err);
16564 if (err) {
16565 goto out;
16566 }
16567
16568out:
16569 error_propagate(errp, err);
16570}
16571
16572void visit_type_q_obj_SocketAddress_base_members(Visitor *v, q_obj_SocketAddress_base *obj, Error **errp)
16573{
16574 Error *err = NULL;
16575
16576 visit_type_SocketAddressType(v, "type", &obj->type, &err);
16577 if (err) {
16578 goto out;
16579 }
16580
16581out:
16582 error_propagate(errp, err);
16583}
16584
16585void visit_type_q_obj_String_wrapper_members(Visitor *v, q_obj_String_wrapper *obj, Error **errp)
16586{
16587 Error *err = NULL;
16588
16589 visit_type_String(v, "data", &obj->data, &err);
16590 if (err) {
16591 goto out;
16592 }
16593
16594out:
16595 error_propagate(errp, err);
16596}
16597
16598void visit_type_q_obj_TPMPassthroughOptions_wrapper_members(Visitor *v, q_obj_TPMPassthroughOptions_wrapper *obj, Error **errp)
16599{
16600 Error *err = NULL;
16601
16602 visit_type_TPMPassthroughOptions(v, "data", &obj->data, &err);
16603 if (err) {
16604 goto out;
16605 }
16606
16607out:
16608 error_propagate(errp, err);
16609}
16610
16611void visit_type_q_obj_UnixSocketAddress_wrapper_members(Visitor *v, q_obj_UnixSocketAddress_wrapper *obj, Error **errp)
16612{
16613 Error *err = NULL;
16614
16615 visit_type_UnixSocketAddress(v, "data", &obj->data, &err);
16616 if (err) {
16617 goto out;
16618 }
16619
16620out:
16621 error_propagate(errp, err);
16622}
16623
16624void visit_type_q_obj_VNC_CONNECTED_arg_members(Visitor *v, q_obj_VNC_CONNECTED_arg *obj, Error **errp)
16625{
16626 Error *err = NULL;
16627
16628 visit_type_VncServerInfo(v, "server", &obj->server, &err);
16629 if (err) {
16630 goto out;
16631 }
16632 visit_type_VncBasicInfo(v, "client", &obj->client, &err);
16633 if (err) {
16634 goto out;
16635 }
16636
16637out:
16638 error_propagate(errp, err);
16639}
16640
16641void visit_type_q_obj_VNC_DISCONNECTED_arg_members(Visitor *v, q_obj_VNC_DISCONNECTED_arg *obj, Error **errp)
16642{
16643 Error *err = NULL;
16644
16645 visit_type_VncServerInfo(v, "server", &obj->server, &err);
16646 if (err) {
16647 goto out;
16648 }
16649 visit_type_VncClientInfo(v, "client", &obj->client, &err);
16650 if (err) {
16651 goto out;
16652 }
16653
16654out:
16655 error_propagate(errp, err);
16656}
16657
16658void visit_type_q_obj_VNC_INITIALIZED_arg_members(Visitor *v, q_obj_VNC_INITIALIZED_arg *obj, Error **errp)
16659{
16660 Error *err = NULL;
16661
16662 visit_type_VncServerInfo(v, "server", &obj->server, &err);
16663 if (err) {
16664 goto out;
16665 }
16666 visit_type_VncClientInfo(v, "client", &obj->client, &err);
16667 if (err) {
16668 goto out;
16669 }
16670
16671out:
16672 error_propagate(errp, err);
16673}
16674
16675void visit_type_q_obj_VSERPORT_CHANGE_arg_members(Visitor *v, q_obj_VSERPORT_CHANGE_arg *obj, Error **errp)
16676{
16677 Error *err = NULL;
16678
16679 visit_type_str(v, "id", &obj->id, &err);
16680 if (err) {
16681 goto out;
16682 }
16683 visit_type_bool(v, "open", &obj->open, &err);
16684 if (err) {
16685 goto out;
16686 }
16687
16688out:
16689 error_propagate(errp, err);
16690}
16691
16692void visit_type_q_obj_VsockSocketAddress_wrapper_members(Visitor *v, q_obj_VsockSocketAddress_wrapper *obj, Error **errp)
16693{
16694 Error *err = NULL;
16695
16696 visit_type_VsockSocketAddress(v, "data", &obj->data, &err);
16697 if (err) {
16698 goto out;
16699 }
16700
16701out:
16702 error_propagate(errp, err);
16703}
16704
16705void visit_type_q_obj_WATCHDOG_arg_members(Visitor *v, q_obj_WATCHDOG_arg *obj, Error **errp)
16706{
16707 Error *err = NULL;
16708
16709 visit_type_WatchdogExpirationAction(v, "action", &obj->action, &err);
16710 if (err) {
16711 goto out;
16712 }
16713
16714out:
16715 error_propagate(errp, err);
16716}
16717
16718void visit_type_q_obj_add_fd_arg_members(Visitor *v, q_obj_add_fd_arg *obj, Error **errp)
16719{
16720 Error *err = NULL;
16721
16722 if (visit_optional(v, "fdset-id", &obj->has_fdset_id)) {
16723 visit_type_int(v, "fdset-id", &obj->fdset_id, &err);
16724 if (err) {
16725 goto out;
16726 }
16727 }
16728 if (visit_optional(v, "opaque", &obj->has_opaque)) {
16729 visit_type_str(v, "opaque", &obj->opaque, &err);
16730 if (err) {
16731 goto out;
16732 }
16733 }
16734
16735out:
16736 error_propagate(errp, err);
16737}
16738
16739void visit_type_q_obj_add_client_arg_members(Visitor *v, q_obj_add_client_arg *obj, Error **errp)
16740{
16741 Error *err = NULL;
16742
16743 visit_type_str(v, "protocol", &obj->protocol, &err);
16744 if (err) {
16745 goto out;
16746 }
16747 visit_type_str(v, "fdname", &obj->fdname, &err);
16748 if (err) {
16749 goto out;
16750 }
16751 if (visit_optional(v, "skipauth", &obj->has_skipauth)) {
16752 visit_type_bool(v, "skipauth", &obj->skipauth, &err);
16753 if (err) {
16754 goto out;
16755 }
16756 }
16757 if (visit_optional(v, "tls", &obj->has_tls)) {
16758 visit_type_bool(v, "tls", &obj->tls, &err);
16759 if (err) {
16760 goto out;
16761 }
16762 }
16763
16764out:
16765 error_propagate(errp, err);
16766}
16767
16768void visit_type_q_obj_balloon_arg_members(Visitor *v, q_obj_balloon_arg *obj, Error **errp)
16769{
16770 Error *err = NULL;
16771
16772 visit_type_int(v, "value", &obj->value, &err);
16773 if (err) {
16774 goto out;
16775 }
16776
16777out:
16778 error_propagate(errp, err);
16779}
16780
16781void visit_type_q_obj_block_commit_arg_members(Visitor *v, q_obj_block_commit_arg *obj, Error **errp)
16782{
16783 Error *err = NULL;
16784
16785 if (visit_optional(v, "job-id", &obj->has_job_id)) {
16786 visit_type_str(v, "job-id", &obj->job_id, &err);
16787 if (err) {
16788 goto out;
16789 }
16790 }
16791 visit_type_str(v, "device", &obj->device, &err);
16792 if (err) {
16793 goto out;
16794 }
16795 if (visit_optional(v, "base", &obj->has_base)) {
16796 visit_type_str(v, "base", &obj->base, &err);
16797 if (err) {
16798 goto out;
16799 }
16800 }
16801 if (visit_optional(v, "top", &obj->has_top)) {
16802 visit_type_str(v, "top", &obj->top, &err);
16803 if (err) {
16804 goto out;
16805 }
16806 }
16807 if (visit_optional(v, "backing-file", &obj->has_backing_file)) {
16808 visit_type_str(v, "backing-file", &obj->backing_file, &err);
16809 if (err) {
16810 goto out;
16811 }
16812 }
16813 if (visit_optional(v, "speed", &obj->has_speed)) {
16814 visit_type_int(v, "speed", &obj->speed, &err);
16815 if (err) {
16816 goto out;
16817 }
16818 }
16819 if (visit_optional(v, "filter-node-name", &obj->has_filter_node_name)) {
16820 visit_type_str(v, "filter-node-name", &obj->filter_node_name, &err);
16821 if (err) {
16822 goto out;
16823 }
16824 }
16825
16826out:
16827 error_propagate(errp, err);
16828}
16829
16830void visit_type_q_obj_block_job_cancel_arg_members(Visitor *v, q_obj_block_job_cancel_arg *obj, Error **errp)
16831{
16832 Error *err = NULL;
16833
16834 visit_type_str(v, "device", &obj->device, &err);
16835 if (err) {
16836 goto out;
16837 }
16838 if (visit_optional(v, "force", &obj->has_force)) {
16839 visit_type_bool(v, "force", &obj->force, &err);
16840 if (err) {
16841 goto out;
16842 }
16843 }
16844
16845out:
16846 error_propagate(errp, err);
16847}
16848
16849void visit_type_q_obj_block_job_complete_arg_members(Visitor *v, q_obj_block_job_complete_arg *obj, Error **errp)
16850{
16851 Error *err = NULL;
16852
16853 visit_type_str(v, "device", &obj->device, &err);
16854 if (err) {
16855 goto out;
16856 }
16857
16858out:
16859 error_propagate(errp, err);
16860}
16861
16862void visit_type_q_obj_block_job_pause_arg_members(Visitor *v, q_obj_block_job_pause_arg *obj, Error **errp)
16863{
16864 Error *err = NULL;
16865
16866 visit_type_str(v, "device", &obj->device, &err);
16867 if (err) {
16868 goto out;
16869 }
16870
16871out:
16872 error_propagate(errp, err);
16873}
16874
16875void visit_type_q_obj_block_job_resume_arg_members(Visitor *v, q_obj_block_job_resume_arg *obj, Error **errp)
16876{
16877 Error *err = NULL;
16878
16879 visit_type_str(v, "device", &obj->device, &err);
16880 if (err) {
16881 goto out;
16882 }
16883
16884out:
16885 error_propagate(errp, err);
16886}
16887
16888void visit_type_q_obj_block_job_set_speed_arg_members(Visitor *v, q_obj_block_job_set_speed_arg *obj, Error **errp)
16889{
16890 Error *err = NULL;
16891
16892 visit_type_str(v, "device", &obj->device, &err);
16893 if (err) {
16894 goto out;
16895 }
16896 visit_type_int(v, "speed", &obj->speed, &err);
16897 if (err) {
16898 goto out;
16899 }
16900
16901out:
16902 error_propagate(errp, err);
16903}
16904
16905void visit_type_q_obj_block_set_write_threshold_arg_members(Visitor *v, q_obj_block_set_write_threshold_arg *obj, Error **errp)
16906{
16907 Error *err = NULL;
16908
16909 visit_type_str(v, "node-name", &obj->node_name, &err);
16910 if (err) {
16911 goto out;
16912 }
16913 visit_type_uint64(v, "write-threshold", &obj->write_threshold, &err);
16914 if (err) {
16915 goto out;
16916 }
16917
16918out:
16919 error_propagate(errp, err);
16920}
16921
16922void visit_type_q_obj_block_stream_arg_members(Visitor *v, q_obj_block_stream_arg *obj, Error **errp)
16923{
16924 Error *err = NULL;
16925
16926 if (visit_optional(v, "job-id", &obj->has_job_id)) {
16927 visit_type_str(v, "job-id", &obj->job_id, &err);
16928 if (err) {
16929 goto out;
16930 }
16931 }
16932 visit_type_str(v, "device", &obj->device, &err);
16933 if (err) {
16934 goto out;
16935 }
16936 if (visit_optional(v, "base", &obj->has_base)) {
16937 visit_type_str(v, "base", &obj->base, &err);
16938 if (err) {
16939 goto out;
16940 }
16941 }
16942 if (visit_optional(v, "base-node", &obj->has_base_node)) {
16943 visit_type_str(v, "base-node", &obj->base_node, &err);
16944 if (err) {
16945 goto out;
16946 }
16947 }
16948 if (visit_optional(v, "backing-file", &obj->has_backing_file)) {
16949 visit_type_str(v, "backing-file", &obj->backing_file, &err);
16950 if (err) {
16951 goto out;
16952 }
16953 }
16954 if (visit_optional(v, "speed", &obj->has_speed)) {
16955 visit_type_int(v, "speed", &obj->speed, &err);
16956 if (err) {
16957 goto out;
16958 }
16959 }
16960 if (visit_optional(v, "on-error", &obj->has_on_error)) {
16961 visit_type_BlockdevOnError(v, "on-error", &obj->on_error, &err);
16962 if (err) {
16963 goto out;
16964 }
16965 }
16966
16967out:
16968 error_propagate(errp, err);
16969}
16970
16971void visit_type_q_obj_block_passwd_arg_members(Visitor *v, q_obj_block_passwd_arg *obj, Error **errp)
16972{
16973 Error *err = NULL;
16974
16975 if (visit_optional(v, "device", &obj->has_device)) {
16976 visit_type_str(v, "device", &obj->device, &err);
16977 if (err) {
16978 goto out;
16979 }
16980 }
16981 if (visit_optional(v, "node-name", &obj->has_node_name)) {
16982 visit_type_str(v, "node-name", &obj->node_name, &err);
16983 if (err) {
16984 goto out;
16985 }
16986 }
16987 visit_type_str(v, "password", &obj->password, &err);
16988 if (err) {
16989 goto out;
16990 }
16991
16992out:
16993 error_propagate(errp, err);
16994}
16995
16996void visit_type_q_obj_block_resize_arg_members(Visitor *v, q_obj_block_resize_arg *obj, Error **errp)
16997{
16998 Error *err = NULL;
16999
17000 if (visit_optional(v, "device", &obj->has_device)) {
17001 visit_type_str(v, "device", &obj->device, &err);
17002 if (err) {
17003 goto out;
17004 }
17005 }
17006 if (visit_optional(v, "node-name", &obj->has_node_name)) {
17007 visit_type_str(v, "node-name", &obj->node_name, &err);
17008 if (err) {
17009 goto out;
17010 }
17011 }
17012 visit_type_int(v, "size", &obj->size, &err);
17013 if (err) {
17014 goto out;
17015 }
17016
17017out:
17018 error_propagate(errp, err);
17019}
17020
17021void visit_type_q_obj_blockdev_change_medium_arg_members(Visitor *v, q_obj_blockdev_change_medium_arg *obj, Error **errp)
17022{
17023 Error *err = NULL;
17024
17025 if (visit_optional(v, "device", &obj->has_device)) {
17026 visit_type_str(v, "device", &obj->device, &err);
17027 if (err) {
17028 goto out;
17029 }
17030 }
17031 if (visit_optional(v, "id", &obj->has_id)) {
17032 visit_type_str(v, "id", &obj->id, &err);
17033 if (err) {
17034 goto out;
17035 }
17036 }
17037 visit_type_str(v, "filename", &obj->filename, &err);
17038 if (err) {
17039 goto out;
17040 }
17041 if (visit_optional(v, "format", &obj->has_format)) {
17042 visit_type_str(v, "format", &obj->format, &err);
17043 if (err) {
17044 goto out;
17045 }
17046 }
17047 if (visit_optional(v, "read-only-mode", &obj->has_read_only_mode)) {
17048 visit_type_BlockdevChangeReadOnlyMode(v, "read-only-mode", &obj->read_only_mode, &err);
17049 if (err) {
17050 goto out;
17051 }
17052 }
17053
17054out:
17055 error_propagate(errp, err);
17056}
17057
17058void visit_type_q_obj_blockdev_close_tray_arg_members(Visitor *v, q_obj_blockdev_close_tray_arg *obj, Error **errp)
17059{
17060 Error *err = NULL;
17061
17062 if (visit_optional(v, "device", &obj->has_device)) {
17063 visit_type_str(v, "device", &obj->device, &err);
17064 if (err) {
17065 goto out;
17066 }
17067 }
17068 if (visit_optional(v, "id", &obj->has_id)) {
17069 visit_type_str(v, "id", &obj->id, &err);
17070 if (err) {
17071 goto out;
17072 }
17073 }
17074
17075out:
17076 error_propagate(errp, err);
17077}
17078
17079void visit_type_q_obj_blockdev_del_arg_members(Visitor *v, q_obj_blockdev_del_arg *obj, Error **errp)
17080{
17081 Error *err = NULL;
17082
17083 visit_type_str(v, "node-name", &obj->node_name, &err);
17084 if (err) {
17085 goto out;
17086 }
17087
17088out:
17089 error_propagate(errp, err);
17090}
17091
17092void visit_type_q_obj_blockdev_mirror_arg_members(Visitor *v, q_obj_blockdev_mirror_arg *obj, Error **errp)
17093{
17094 Error *err = NULL;
17095
17096 if (visit_optional(v, "job-id", &obj->has_job_id)) {
17097 visit_type_str(v, "job-id", &obj->job_id, &err);
17098 if (err) {
17099 goto out;
17100 }
17101 }
17102 visit_type_str(v, "device", &obj->device, &err);
17103 if (err) {
17104 goto out;
17105 }
17106 visit_type_str(v, "target", &obj->target, &err);
17107 if (err) {
17108 goto out;
17109 }
17110 if (visit_optional(v, "replaces", &obj->has_replaces)) {
17111 visit_type_str(v, "replaces", &obj->replaces, &err);
17112 if (err) {
17113 goto out;
17114 }
17115 }
17116 visit_type_MirrorSyncMode(v, "sync", &obj->sync, &err);
17117 if (err) {
17118 goto out;
17119 }
17120 if (visit_optional(v, "speed", &obj->has_speed)) {
17121 visit_type_int(v, "speed", &obj->speed, &err);
17122 if (err) {
17123 goto out;
17124 }
17125 }
17126 if (visit_optional(v, "granularity", &obj->has_granularity)) {
17127 visit_type_uint32(v, "granularity", &obj->granularity, &err);
17128 if (err) {
17129 goto out;
17130 }
17131 }
17132 if (visit_optional(v, "buf-size", &obj->has_buf_size)) {
17133 visit_type_int(v, "buf-size", &obj->buf_size, &err);
17134 if (err) {
17135 goto out;
17136 }
17137 }
17138 if (visit_optional(v, "on-source-error", &obj->has_on_source_error)) {
17139 visit_type_BlockdevOnError(v, "on-source-error", &obj->on_source_error, &err);
17140 if (err) {
17141 goto out;
17142 }
17143 }
17144 if (visit_optional(v, "on-target-error", &obj->has_on_target_error)) {
17145 visit_type_BlockdevOnError(v, "on-target-error", &obj->on_target_error, &err);
17146 if (err) {
17147 goto out;
17148 }
17149 }
17150 if (visit_optional(v, "filter-node-name", &obj->has_filter_node_name)) {
17151 visit_type_str(v, "filter-node-name", &obj->filter_node_name, &err);
17152 if (err) {
17153 goto out;
17154 }
17155 }
17156
17157out:
17158 error_propagate(errp, err);
17159}
17160
17161void visit_type_q_obj_blockdev_open_tray_arg_members(Visitor *v, q_obj_blockdev_open_tray_arg *obj, Error **errp)
17162{
17163 Error *err = NULL;
17164
17165 if (visit_optional(v, "device", &obj->has_device)) {
17166 visit_type_str(v, "device", &obj->device, &err);
17167 if (err) {
17168 goto out;
17169 }
17170 }
17171 if (visit_optional(v, "id", &obj->has_id)) {
17172 visit_type_str(v, "id", &obj->id, &err);
17173 if (err) {
17174 goto out;
17175 }
17176 }
17177 if (visit_optional(v, "force", &obj->has_force)) {
17178 visit_type_bool(v, "force", &obj->force, &err);
17179 if (err) {
17180 goto out;
17181 }
17182 }
17183
17184out:
17185 error_propagate(errp, err);
17186}
17187
17188void visit_type_q_obj_blockdev_snapshot_delete_internal_sync_arg_members(Visitor *v, q_obj_blockdev_snapshot_delete_internal_sync_arg *obj, Error **errp)
17189{
17190 Error *err = NULL;
17191
17192 visit_type_str(v, "device", &obj->device, &err);
17193 if (err) {
17194 goto out;
17195 }
17196 if (visit_optional(v, "id", &obj->has_id)) {
17197 visit_type_str(v, "id", &obj->id, &err);
17198 if (err) {
17199 goto out;
17200 }
17201 }
17202 if (visit_optional(v, "name", &obj->has_name)) {
17203 visit_type_str(v, "name", &obj->name, &err);
17204 if (err) {
17205 goto out;
17206 }
17207 }
17208
17209out:
17210 error_propagate(errp, err);
17211}
17212
17213void visit_type_q_obj_change_arg_members(Visitor *v, q_obj_change_arg *obj, Error **errp)
17214{
17215 Error *err = NULL;
17216
17217 visit_type_str(v, "device", &obj->device, &err);
17218 if (err) {
17219 goto out;
17220 }
17221 visit_type_str(v, "target", &obj->target, &err);
17222 if (err) {
17223 goto out;
17224 }
17225 if (visit_optional(v, "arg", &obj->has_arg)) {
17226 visit_type_str(v, "arg", &obj->arg, &err);
17227 if (err) {
17228 goto out;
17229 }
17230 }
17231
17232out:
17233 error_propagate(errp, err);
17234}
17235
17236void visit_type_q_obj_change_backing_file_arg_members(Visitor *v, q_obj_change_backing_file_arg *obj, Error **errp)
17237{
17238 Error *err = NULL;
17239
17240 visit_type_str(v, "device", &obj->device, &err);
17241 if (err) {
17242 goto out;
17243 }
17244 visit_type_str(v, "image-node-name", &obj->image_node_name, &err);
17245 if (err) {
17246 goto out;
17247 }
17248 visit_type_str(v, "backing-file", &obj->backing_file, &err);
17249 if (err) {
17250 goto out;
17251 }
17252
17253out:
17254 error_propagate(errp, err);
17255}
17256
17257void visit_type_q_obj_change_vnc_password_arg_members(Visitor *v, q_obj_change_vnc_password_arg *obj, Error **errp)
17258{
17259 Error *err = NULL;
17260
17261 visit_type_str(v, "password", &obj->password, &err);
17262 if (err) {
17263 goto out;
17264 }
17265
17266out:
17267 error_propagate(errp, err);
17268}
17269
17270void visit_type_q_obj_chardev_add_arg_members(Visitor *v, q_obj_chardev_add_arg *obj, Error **errp)
17271{
17272 Error *err = NULL;
17273
17274 visit_type_str(v, "id", &obj->id, &err);
17275 if (err) {
17276 goto out;
17277 }
17278 visit_type_ChardevBackend(v, "backend", &obj->backend, &err);
17279 if (err) {
17280 goto out;
17281 }
17282
17283out:
17284 error_propagate(errp, err);
17285}
17286
17287void visit_type_q_obj_chardev_change_arg_members(Visitor *v, q_obj_chardev_change_arg *obj, Error **errp)
17288{
17289 Error *err = NULL;
17290
17291 visit_type_str(v, "id", &obj->id, &err);
17292 if (err) {
17293 goto out;
17294 }
17295 visit_type_ChardevBackend(v, "backend", &obj->backend, &err);
17296 if (err) {
17297 goto out;
17298 }
17299
17300out:
17301 error_propagate(errp, err);
17302}
17303
17304void visit_type_q_obj_chardev_remove_arg_members(Visitor *v, q_obj_chardev_remove_arg *obj, Error **errp)
17305{
17306 Error *err = NULL;
17307
17308 visit_type_str(v, "id", &obj->id, &err);
17309 if (err) {
17310 goto out;
17311 }
17312
17313out:
17314 error_propagate(errp, err);
17315}
17316
17317void visit_type_q_obj_chardev_send_break_arg_members(Visitor *v, q_obj_chardev_send_break_arg *obj, Error **errp)
17318{
17319 Error *err = NULL;
17320
17321 visit_type_str(v, "id", &obj->id, &err);
17322 if (err) {
17323 goto out;
17324 }
17325
17326out:
17327 error_propagate(errp, err);
17328}
17329
17330void visit_type_q_obj_client_migrate_info_arg_members(Visitor *v, q_obj_client_migrate_info_arg *obj, Error **errp)
17331{
17332 Error *err = NULL;
17333
17334 visit_type_str(v, "protocol", &obj->protocol, &err);
17335 if (err) {
17336 goto out;
17337 }
17338 visit_type_str(v, "hostname", &obj->hostname, &err);
17339 if (err) {
17340 goto out;
17341 }
17342 if (visit_optional(v, "port", &obj->has_port)) {
17343 visit_type_int(v, "port", &obj->port, &err);
17344 if (err) {
17345 goto out;
17346 }
17347 }
17348 if (visit_optional(v, "tls-port", &obj->has_tls_port)) {
17349 visit_type_int(v, "tls-port", &obj->tls_port, &err);
17350 if (err) {
17351 goto out;
17352 }
17353 }
17354 if (visit_optional(v, "cert-subject", &obj->has_cert_subject)) {
17355 visit_type_str(v, "cert-subject", &obj->cert_subject, &err);
17356 if (err) {
17357 goto out;
17358 }
17359 }
17360
17361out:
17362 error_propagate(errp, err);
17363}
17364
17365void visit_type_q_obj_closefd_arg_members(Visitor *v, q_obj_closefd_arg *obj, Error **errp)
17366{
17367 Error *err = NULL;
17368
17369 visit_type_str(v, "fdname", &obj->fdname, &err);
17370 if (err) {
17371 goto out;
17372 }
17373
17374out:
17375 error_propagate(errp, err);
17376}
17377
17378void visit_type_q_obj_cpu_add_arg_members(Visitor *v, q_obj_cpu_add_arg *obj, Error **errp)
17379{
17380 Error *err = NULL;
17381
17382 visit_type_int(v, "id", &obj->id, &err);
17383 if (err) {
17384 goto out;
17385 }
17386
17387out:
17388 error_propagate(errp, err);
17389}
17390
17391void visit_type_q_obj_cpu_arg_members(Visitor *v, q_obj_cpu_arg *obj, Error **errp)
17392{
17393 Error *err = NULL;
17394
17395 visit_type_int(v, "index", &obj->index, &err);
17396 if (err) {
17397 goto out;
17398 }
17399
17400out:
17401 error_propagate(errp, err);
17402}
17403
17404void visit_type_q_obj_device_list_properties_arg_members(Visitor *v, q_obj_device_list_properties_arg *obj, Error **errp)
17405{
17406 Error *err = NULL;
17407
17408 visit_type_str(v, "typename", &obj->q_typename, &err);
17409 if (err) {
17410 goto out;
17411 }
17412
17413out:
17414 error_propagate(errp, err);
17415}
17416
17417void visit_type_q_obj_device_add_arg_members(Visitor *v, q_obj_device_add_arg *obj, Error **errp)
17418{
17419 Error *err = NULL;
17420
17421 visit_type_str(v, "driver", &obj->driver, &err);
17422 if (err) {
17423 goto out;
17424 }
17425 if (visit_optional(v, "bus", &obj->has_bus)) {
17426 visit_type_str(v, "bus", &obj->bus, &err);
17427 if (err) {
17428 goto out;
17429 }
17430 }
17431 if (visit_optional(v, "id", &obj->has_id)) {
17432 visit_type_str(v, "id", &obj->id, &err);
17433 if (err) {
17434 goto out;
17435 }
17436 }
17437
17438out:
17439 error_propagate(errp, err);
17440}
17441
17442void visit_type_q_obj_device_del_arg_members(Visitor *v, q_obj_device_del_arg *obj, Error **errp)
17443{
17444 Error *err = NULL;
17445
17446 visit_type_str(v, "id", &obj->id, &err);
17447 if (err) {
17448 goto out;
17449 }
17450
17451out:
17452 error_propagate(errp, err);
17453}
17454
17455void visit_type_q_obj_dump_guest_memory_arg_members(Visitor *v, q_obj_dump_guest_memory_arg *obj, Error **errp)
17456{
17457 Error *err = NULL;
17458
17459 visit_type_bool(v, "paging", &obj->paging, &err);
17460 if (err) {
17461 goto out;
17462 }
17463 visit_type_str(v, "protocol", &obj->protocol, &err);
17464 if (err) {
17465 goto out;
17466 }
17467 if (visit_optional(v, "detach", &obj->has_detach)) {
17468 visit_type_bool(v, "detach", &obj->detach, &err);
17469 if (err) {
17470 goto out;
17471 }
17472 }
17473 if (visit_optional(v, "begin", &obj->has_begin)) {
17474 visit_type_int(v, "begin", &obj->begin, &err);
17475 if (err) {
17476 goto out;
17477 }
17478 }
17479 if (visit_optional(v, "length", &obj->has_length)) {
17480 visit_type_int(v, "length", &obj->length, &err);
17481 if (err) {
17482 goto out;
17483 }
17484 }
17485 if (visit_optional(v, "format", &obj->has_format)) {
17486 visit_type_DumpGuestMemoryFormat(v, "format", &obj->format, &err);
17487 if (err) {
17488 goto out;
17489 }
17490 }
17491
17492out:
17493 error_propagate(errp, err);
17494}
17495
17496void visit_type_q_obj_dump_skeys_arg_members(Visitor *v, q_obj_dump_skeys_arg *obj, Error **errp)
17497{
17498 Error *err = NULL;
17499
17500 visit_type_str(v, "filename", &obj->filename, &err);
17501 if (err) {
17502 goto out;
17503 }
17504
17505out:
17506 error_propagate(errp, err);
17507}
17508
17509void visit_type_q_obj_eject_arg_members(Visitor *v, q_obj_eject_arg *obj, Error **errp)
17510{
17511 Error *err = NULL;
17512
17513 if (visit_optional(v, "device", &obj->has_device)) {
17514 visit_type_str(v, "device", &obj->device, &err);
17515 if (err) {
17516 goto out;
17517 }
17518 }
17519 if (visit_optional(v, "id", &obj->has_id)) {
17520 visit_type_str(v, "id", &obj->id, &err);
17521 if (err) {
17522 goto out;
17523 }
17524 }
17525 if (visit_optional(v, "force", &obj->has_force)) {
17526 visit_type_bool(v, "force", &obj->force, &err);
17527 if (err) {
17528 goto out;
17529 }
17530 }
17531
17532out:
17533 error_propagate(errp, err);
17534}
17535
17536void visit_type_q_obj_expire_password_arg_members(Visitor *v, q_obj_expire_password_arg *obj, Error **errp)
17537{
17538 Error *err = NULL;
17539
17540 visit_type_str(v, "protocol", &obj->protocol, &err);
17541 if (err) {
17542 goto out;
17543 }
17544 visit_type_str(v, "time", &obj->time, &err);
17545 if (err) {
17546 goto out;
17547 }
17548
17549out:
17550 error_propagate(errp, err);
17551}
17552
17553void visit_type_q_obj_getfd_arg_members(Visitor *v, q_obj_getfd_arg *obj, Error **errp)
17554{
17555 Error *err = NULL;
17556
17557 visit_type_str(v, "fdname", &obj->fdname, &err);
17558 if (err) {
17559 goto out;
17560 }
17561
17562out:
17563 error_propagate(errp, err);
17564}
17565
17566void visit_type_q_obj_human_monitor_command_arg_members(Visitor *v, q_obj_human_monitor_command_arg *obj, Error **errp)
17567{
17568 Error *err = NULL;
17569
17570 visit_type_str(v, "command-line", &obj->command_line, &err);
17571 if (err) {
17572 goto out;
17573 }
17574 if (visit_optional(v, "cpu-index", &obj->has_cpu_index)) {
17575 visit_type_int(v, "cpu-index", &obj->cpu_index, &err);
17576 if (err) {
17577 goto out;
17578 }
17579 }
17580
17581out:
17582 error_propagate(errp, err);
17583}
17584
17585void visit_type_q_obj_input_send_event_arg_members(Visitor *v, q_obj_input_send_event_arg *obj, Error **errp)
17586{
17587 Error *err = NULL;
17588
17589 if (visit_optional(v, "device", &obj->has_device)) {
17590 visit_type_str(v, "device", &obj->device, &err);
17591 if (err) {
17592 goto out;
17593 }
17594 }
17595 if (visit_optional(v, "head", &obj->has_head)) {
17596 visit_type_int(v, "head", &obj->head, &err);
17597 if (err) {
17598 goto out;
17599 }
17600 }
17601 visit_type_InputEventList(v, "events", &obj->events, &err);
17602 if (err) {
17603 goto out;
17604 }
17605
17606out:
17607 error_propagate(errp, err);
17608}
17609
17610void visit_type_q_obj_int_wrapper_members(Visitor *v, q_obj_int_wrapper *obj, Error **errp)
17611{
17612 Error *err = NULL;
17613
17614 visit_type_int(v, "data", &obj->data, &err);
17615 if (err) {
17616 goto out;
17617 }
17618
17619out:
17620 error_propagate(errp, err);
17621}
17622
17623void visit_type_q_obj_memsave_arg_members(Visitor *v, q_obj_memsave_arg *obj, Error **errp)
17624{
17625 Error *err = NULL;
17626
17627 visit_type_int(v, "val", &obj->val, &err);
17628 if (err) {
17629 goto out;
17630 }
17631 visit_type_int(v, "size", &obj->size, &err);
17632 if (err) {
17633 goto out;
17634 }
17635 visit_type_str(v, "filename", &obj->filename, &err);
17636 if (err) {
17637 goto out;
17638 }
17639 if (visit_optional(v, "cpu-index", &obj->has_cpu_index)) {
17640 visit_type_int(v, "cpu-index", &obj->cpu_index, &err);
17641 if (err) {
17642 goto out;
17643 }
17644 }
17645
17646out:
17647 error_propagate(errp, err);
17648}
17649
17650void visit_type_q_obj_migrate_arg_members(Visitor *v, q_obj_migrate_arg *obj, Error **errp)
17651{
17652 Error *err = NULL;
17653
17654 visit_type_str(v, "uri", &obj->uri, &err);
17655 if (err) {
17656 goto out;
17657 }
17658 if (visit_optional(v, "blk", &obj->has_blk)) {
17659 visit_type_bool(v, "blk", &obj->blk, &err);
17660 if (err) {
17661 goto out;
17662 }
17663 }
17664 if (visit_optional(v, "inc", &obj->has_inc)) {
17665 visit_type_bool(v, "inc", &obj->inc, &err);
17666 if (err) {
17667 goto out;
17668 }
17669 }
17670 if (visit_optional(v, "detach", &obj->has_detach)) {
17671 visit_type_bool(v, "detach", &obj->detach, &err);
17672 if (err) {
17673 goto out;
17674 }
17675 }
17676
17677out:
17678 error_propagate(errp, err);
17679}
17680
17681void visit_type_q_obj_migrate_incoming_arg_members(Visitor *v, q_obj_migrate_incoming_arg *obj, Error **errp)
17682{
17683 Error *err = NULL;
17684
17685 visit_type_str(v, "uri", &obj->uri, &err);
17686 if (err) {
17687 goto out;
17688 }
17689
17690out:
17691 error_propagate(errp, err);
17692}
17693
17694void visit_type_q_obj_migrate_set_cache_size_arg_members(Visitor *v, q_obj_migrate_set_cache_size_arg *obj, Error **errp)
17695{
17696 Error *err = NULL;
17697
17698 visit_type_int(v, "value", &obj->value, &err);
17699 if (err) {
17700 goto out;
17701 }
17702
17703out:
17704 error_propagate(errp, err);
17705}
17706
17707void visit_type_q_obj_migrate_set_capabilities_arg_members(Visitor *v, q_obj_migrate_set_capabilities_arg *obj, Error **errp)
17708{
17709 Error *err = NULL;
17710
17711 visit_type_MigrationCapabilityStatusList(v, "capabilities", &obj->capabilities, &err);
17712 if (err) {
17713 goto out;
17714 }
17715
17716out:
17717 error_propagate(errp, err);
17718}
17719
17720void visit_type_q_obj_migrate_set_downtime_arg_members(Visitor *v, q_obj_migrate_set_downtime_arg *obj, Error **errp)
17721{
17722 Error *err = NULL;
17723
17724 visit_type_number(v, "value", &obj->value, &err);
17725 if (err) {
17726 goto out;
17727 }
17728
17729out:
17730 error_propagate(errp, err);
17731}
17732
17733void visit_type_q_obj_migrate_set_speed_arg_members(Visitor *v, q_obj_migrate_set_speed_arg *obj, Error **errp)
17734{
17735 Error *err = NULL;
17736
17737 visit_type_int(v, "value", &obj->value, &err);
17738 if (err) {
17739 goto out;
17740 }
17741
17742out:
17743 error_propagate(errp, err);
17744}
17745
17746void visit_type_q_obj_nbd_server_add_arg_members(Visitor *v, q_obj_nbd_server_add_arg *obj, Error **errp)
17747{
17748 Error *err = NULL;
17749
17750 visit_type_str(v, "device", &obj->device, &err);
17751 if (err) {
17752 goto out;
17753 }
17754 if (visit_optional(v, "writable", &obj->has_writable)) {
17755 visit_type_bool(v, "writable", &obj->writable, &err);
17756 if (err) {
17757 goto out;
17758 }
17759 }
17760
17761out:
17762 error_propagate(errp, err);
17763}
17764
17765void visit_type_q_obj_nbd_server_start_arg_members(Visitor *v, q_obj_nbd_server_start_arg *obj, Error **errp)
17766{
17767 Error *err = NULL;
17768
17769 visit_type_SocketAddressLegacy(v, "addr", &obj->addr, &err);
17770 if (err) {
17771 goto out;
17772 }
17773 if (visit_optional(v, "tls-creds", &obj->has_tls_creds)) {
17774 visit_type_str(v, "tls-creds", &obj->tls_creds, &err);
17775 if (err) {
17776 goto out;
17777 }
17778 }
17779
17780out:
17781 error_propagate(errp, err);
17782}
17783
17784void visit_type_q_obj_netdev_add_arg_members(Visitor *v, q_obj_netdev_add_arg *obj, Error **errp)
17785{
17786 Error *err = NULL;
17787
17788 visit_type_str(v, "type", &obj->type, &err);
17789 if (err) {
17790 goto out;
17791 }
17792 visit_type_str(v, "id", &obj->id, &err);
17793 if (err) {
17794 goto out;
17795 }
17796
17797out:
17798 error_propagate(errp, err);
17799}
17800
17801void visit_type_q_obj_netdev_del_arg_members(Visitor *v, q_obj_netdev_del_arg *obj, Error **errp)
17802{
17803 Error *err = NULL;
17804
17805 visit_type_str(v, "id", &obj->id, &err);
17806 if (err) {
17807 goto out;
17808 }
17809
17810out:
17811 error_propagate(errp, err);
17812}
17813
17814void visit_type_q_obj_object_add_arg_members(Visitor *v, q_obj_object_add_arg *obj, Error **errp)
17815{
17816 Error *err = NULL;
17817
17818 visit_type_str(v, "qom-type", &obj->qom_type, &err);
17819 if (err) {
17820 goto out;
17821 }
17822 visit_type_str(v, "id", &obj->id, &err);
17823 if (err) {
17824 goto out;
17825 }
17826 if (visit_optional(v, "props", &obj->has_props)) {
17827 visit_type_any(v, "props", &obj->props, &err);
17828 if (err) {
17829 goto out;
17830 }
17831 }
17832
17833out:
17834 error_propagate(errp, err);
17835}
17836
17837void visit_type_q_obj_object_del_arg_members(Visitor *v, q_obj_object_del_arg *obj, Error **errp)
17838{
17839 Error *err = NULL;
17840
17841 visit_type_str(v, "id", &obj->id, &err);
17842 if (err) {
17843 goto out;
17844 }
17845
17846out:
17847 error_propagate(errp, err);
17848}
17849
17850void visit_type_q_obj_pmemsave_arg_members(Visitor *v, q_obj_pmemsave_arg *obj, Error **errp)
17851{
17852 Error *err = NULL;
17853
17854 visit_type_int(v, "val", &obj->val, &err);
17855 if (err) {
17856 goto out;
17857 }
17858 visit_type_int(v, "size", &obj->size, &err);
17859 if (err) {
17860 goto out;
17861 }
17862 visit_type_str(v, "filename", &obj->filename, &err);
17863 if (err) {
17864 goto out;
17865 }
17866
17867out:
17868 error_propagate(errp, err);
17869}
17870
17871void visit_type_q_obj_qom_get_arg_members(Visitor *v, q_obj_qom_get_arg *obj, Error **errp)
17872{
17873 Error *err = NULL;
17874
17875 visit_type_str(v, "path", &obj->path, &err);
17876 if (err) {
17877 goto out;
17878 }
17879 visit_type_str(v, "property", &obj->property, &err);
17880 if (err) {
17881 goto out;
17882 }
17883
17884out:
17885 error_propagate(errp, err);
17886}
17887
17888void visit_type_q_obj_qom_list_arg_members(Visitor *v, q_obj_qom_list_arg *obj, Error **errp)
17889{
17890 Error *err = NULL;
17891
17892 visit_type_str(v, "path", &obj->path, &err);
17893 if (err) {
17894 goto out;
17895 }
17896
17897out:
17898 error_propagate(errp, err);
17899}
17900
17901void visit_type_q_obj_qom_list_types_arg_members(Visitor *v, q_obj_qom_list_types_arg *obj, Error **errp)
17902{
17903 Error *err = NULL;
17904
17905 if (visit_optional(v, "implements", &obj->has_implements)) {
17906 visit_type_str(v, "implements", &obj->implements, &err);
17907 if (err) {
17908 goto out;
17909 }
17910 }
17911 if (visit_optional(v, "abstract", &obj->has_abstract)) {
17912 visit_type_bool(v, "abstract", &obj->abstract, &err);
17913 if (err) {
17914 goto out;
17915 }
17916 }
17917
17918out:
17919 error_propagate(errp, err);
17920}
17921
17922void visit_type_q_obj_qom_set_arg_members(Visitor *v, q_obj_qom_set_arg *obj, Error **errp)
17923{
17924 Error *err = NULL;
17925
17926 visit_type_str(v, "path", &obj->path, &err);
17927 if (err) {
17928 goto out;
17929 }
17930 visit_type_str(v, "property", &obj->property, &err);
17931 if (err) {
17932 goto out;
17933 }
17934 visit_type_any(v, "value", &obj->value, &err);
17935 if (err) {
17936 goto out;
17937 }
17938
17939out:
17940 error_propagate(errp, err);
17941}
17942
17943void visit_type_q_obj_query_blockstats_arg_members(Visitor *v, q_obj_query_blockstats_arg *obj, Error **errp)
17944{
17945 Error *err = NULL;
17946
17947 if (visit_optional(v, "query-nodes", &obj->has_query_nodes)) {
17948 visit_type_bool(v, "query-nodes", &obj->query_nodes, &err);
17949 if (err) {
17950 goto out;
17951 }
17952 }
17953
17954out:
17955 error_propagate(errp, err);
17956}
17957
17958void visit_type_q_obj_query_command_line_options_arg_members(Visitor *v, q_obj_query_command_line_options_arg *obj, Error **errp)
17959{
17960 Error *err = NULL;
17961
17962 if (visit_optional(v, "option", &obj->has_option)) {
17963 visit_type_str(v, "option", &obj->option, &err);
17964 if (err) {
17965 goto out;
17966 }
17967 }
17968
17969out:
17970 error_propagate(errp, err);
17971}
17972
17973void visit_type_q_obj_query_cpu_model_baseline_arg_members(Visitor *v, q_obj_query_cpu_model_baseline_arg *obj, Error **errp)
17974{
17975 Error *err = NULL;
17976
17977 visit_type_CpuModelInfo(v, "modela", &obj->modela, &err);
17978 if (err) {
17979 goto out;
17980 }
17981 visit_type_CpuModelInfo(v, "modelb", &obj->modelb, &err);
17982 if (err) {
17983 goto out;
17984 }
17985
17986out:
17987 error_propagate(errp, err);
17988}
17989
17990void visit_type_q_obj_query_cpu_model_comparison_arg_members(Visitor *v, q_obj_query_cpu_model_comparison_arg *obj, Error **errp)
17991{
17992 Error *err = NULL;
17993
17994 visit_type_CpuModelInfo(v, "modela", &obj->modela, &err);
17995 if (err) {
17996 goto out;
17997 }
17998 visit_type_CpuModelInfo(v, "modelb", &obj->modelb, &err);
17999 if (err) {
18000 goto out;
18001 }
18002
18003out:
18004 error_propagate(errp, err);
18005}
18006
18007void visit_type_q_obj_query_cpu_model_expansion_arg_members(Visitor *v, q_obj_query_cpu_model_expansion_arg *obj, Error **errp)
18008{
18009 Error *err = NULL;
18010
18011 visit_type_CpuModelExpansionType(v, "type", &obj->type, &err);
18012 if (err) {
18013 goto out;
18014 }
18015 visit_type_CpuModelInfo(v, "model", &obj->model, &err);
18016 if (err) {
18017 goto out;
18018 }
18019
18020out:
18021 error_propagate(errp, err);
18022}
18023
18024void visit_type_q_obj_query_rocker_arg_members(Visitor *v, q_obj_query_rocker_arg *obj, Error **errp)
18025{
18026 Error *err = NULL;
18027
18028 visit_type_str(v, "name", &obj->name, &err);
18029 if (err) {
18030 goto out;
18031 }
18032
18033out:
18034 error_propagate(errp, err);
18035}
18036
18037void visit_type_q_obj_query_rocker_of_dpa_flows_arg_members(Visitor *v, q_obj_query_rocker_of_dpa_flows_arg *obj, Error **errp)
18038{
18039 Error *err = NULL;
18040
18041 visit_type_str(v, "name", &obj->name, &err);
18042 if (err) {
18043 goto out;
18044 }
18045 if (visit_optional(v, "tbl-id", &obj->has_tbl_id)) {
18046 visit_type_uint32(v, "tbl-id", &obj->tbl_id, &err);
18047 if (err) {
18048 goto out;
18049 }
18050 }
18051
18052out:
18053 error_propagate(errp, err);
18054}
18055
18056void visit_type_q_obj_query_rocker_of_dpa_groups_arg_members(Visitor *v, q_obj_query_rocker_of_dpa_groups_arg *obj, Error **errp)
18057{
18058 Error *err = NULL;
18059
18060 visit_type_str(v, "name", &obj->name, &err);
18061 if (err) {
18062 goto out;
18063 }
18064 if (visit_optional(v, "type", &obj->has_type)) {
18065 visit_type_uint8(v, "type", &obj->type, &err);
18066 if (err) {
18067 goto out;
18068 }
18069 }
18070
18071out:
18072 error_propagate(errp, err);
18073}
18074
18075void visit_type_q_obj_query_rocker_ports_arg_members(Visitor *v, q_obj_query_rocker_ports_arg *obj, Error **errp)
18076{
18077 Error *err = NULL;
18078
18079 visit_type_str(v, "name", &obj->name, &err);
18080 if (err) {
18081 goto out;
18082 }
18083
18084out:
18085 error_propagate(errp, err);
18086}
18087
18088void visit_type_q_obj_query_rx_filter_arg_members(Visitor *v, q_obj_query_rx_filter_arg *obj, Error **errp)
18089{
18090 Error *err = NULL;
18091
18092 if (visit_optional(v, "name", &obj->has_name)) {
18093 visit_type_str(v, "name", &obj->name, &err);
18094 if (err) {
18095 goto out;
18096 }
18097 }
18098
18099out:
18100 error_propagate(errp, err);
18101}
18102
18103void visit_type_q_obj_remove_fd_arg_members(Visitor *v, q_obj_remove_fd_arg *obj, Error **errp)
18104{
18105 Error *err = NULL;
18106
18107 visit_type_int(v, "fdset-id", &obj->fdset_id, &err);
18108 if (err) {
18109 goto out;
18110 }
18111 if (visit_optional(v, "fd", &obj->has_fd)) {
18112 visit_type_int(v, "fd", &obj->fd, &err);
18113 if (err) {
18114 goto out;
18115 }
18116 }
18117
18118out:
18119 error_propagate(errp, err);
18120}
18121
18122void visit_type_q_obj_ringbuf_read_arg_members(Visitor *v, q_obj_ringbuf_read_arg *obj, Error **errp)
18123{
18124 Error *err = NULL;
18125
18126 visit_type_str(v, "device", &obj->device, &err);
18127 if (err) {
18128 goto out;
18129 }
18130 visit_type_int(v, "size", &obj->size, &err);
18131 if (err) {
18132 goto out;
18133 }
18134 if (visit_optional(v, "format", &obj->has_format)) {
18135 visit_type_DataFormat(v, "format", &obj->format, &err);
18136 if (err) {
18137 goto out;
18138 }
18139 }
18140
18141out:
18142 error_propagate(errp, err);
18143}
18144
18145void visit_type_q_obj_ringbuf_write_arg_members(Visitor *v, q_obj_ringbuf_write_arg *obj, Error **errp)
18146{
18147 Error *err = NULL;
18148
18149 visit_type_str(v, "device", &obj->device, &err);
18150 if (err) {
18151 goto out;
18152 }
18153 visit_type_str(v, "data", &obj->data, &err);
18154 if (err) {
18155 goto out;
18156 }
18157 if (visit_optional(v, "format", &obj->has_format)) {
18158 visit_type_DataFormat(v, "format", &obj->format, &err);
18159 if (err) {
18160 goto out;
18161 }
18162 }
18163
18164out:
18165 error_propagate(errp, err);
18166}
18167
18168void visit_type_q_obj_screendump_arg_members(Visitor *v, q_obj_screendump_arg *obj, Error **errp)
18169{
18170 Error *err = NULL;
18171
18172 visit_type_str(v, "filename", &obj->filename, &err);
18173 if (err) {
18174 goto out;
18175 }
18176
18177out:
18178 error_propagate(errp, err);
18179}
18180
18181void visit_type_q_obj_send_key_arg_members(Visitor *v, q_obj_send_key_arg *obj, Error **errp)
18182{
18183 Error *err = NULL;
18184
18185 visit_type_KeyValueList(v, "keys", &obj->keys, &err);
18186 if (err) {
18187 goto out;
18188 }
18189 if (visit_optional(v, "hold-time", &obj->has_hold_time)) {
18190 visit_type_int(v, "hold-time", &obj->hold_time, &err);
18191 if (err) {
18192 goto out;
18193 }
18194 }
18195
18196out:
18197 error_propagate(errp, err);
18198}
18199
18200void visit_type_q_obj_set_link_arg_members(Visitor *v, q_obj_set_link_arg *obj, Error **errp)
18201{
18202 Error *err = NULL;
18203
18204 visit_type_str(v, "name", &obj->name, &err);
18205 if (err) {
18206 goto out;
18207 }
18208 visit_type_bool(v, "up", &obj->up, &err);
18209 if (err) {
18210 goto out;
18211 }
18212
18213out:
18214 error_propagate(errp, err);
18215}
18216
18217void visit_type_q_obj_set_password_arg_members(Visitor *v, q_obj_set_password_arg *obj, Error **errp)
18218{
18219 Error *err = NULL;
18220
18221 visit_type_str(v, "protocol", &obj->protocol, &err);
18222 if (err) {
18223 goto out;
18224 }
18225 visit_type_str(v, "password", &obj->password, &err);
18226 if (err) {
18227 goto out;
18228 }
18229 if (visit_optional(v, "connected", &obj->has_connected)) {
18230 visit_type_str(v, "connected", &obj->connected, &err);
18231 if (err) {
18232 goto out;
18233 }
18234 }
18235
18236out:
18237 error_propagate(errp, err);
18238}
18239
18240void visit_type_q_obj_trace_event_get_state_arg_members(Visitor *v, q_obj_trace_event_get_state_arg *obj, Error **errp)
18241{
18242 Error *err = NULL;
18243
18244 visit_type_str(v, "name", &obj->name, &err);
18245 if (err) {
18246 goto out;
18247 }
18248 if (visit_optional(v, "vcpu", &obj->has_vcpu)) {
18249 visit_type_int(v, "vcpu", &obj->vcpu, &err);
18250 if (err) {
18251 goto out;
18252 }
18253 }
18254
18255out:
18256 error_propagate(errp, err);
18257}
18258
18259void visit_type_q_obj_trace_event_set_state_arg_members(Visitor *v, q_obj_trace_event_set_state_arg *obj, Error **errp)
18260{
18261 Error *err = NULL;
18262
18263 visit_type_str(v, "name", &obj->name, &err);
18264 if (err) {
18265 goto out;
18266 }
18267 visit_type_bool(v, "enable", &obj->enable, &err);
18268 if (err) {
18269 goto out;
18270 }
18271 if (visit_optional(v, "ignore-unavailable", &obj->has_ignore_unavailable)) {
18272 visit_type_bool(v, "ignore-unavailable", &obj->ignore_unavailable, &err);
18273 if (err) {
18274 goto out;
18275 }
18276 }
18277 if (visit_optional(v, "vcpu", &obj->has_vcpu)) {
18278 visit_type_int(v, "vcpu", &obj->vcpu, &err);
18279 if (err) {
18280 goto out;
18281 }
18282 }
18283
18284out:
18285 error_propagate(errp, err);
18286}
18287
18288void visit_type_q_obj_transaction_arg_members(Visitor *v, q_obj_transaction_arg *obj, Error **errp)
18289{
18290 Error *err = NULL;
18291
18292 visit_type_TransactionActionList(v, "actions", &obj->actions, &err);
18293 if (err) {
18294 goto out;
18295 }
18296 if (visit_optional(v, "properties", &obj->has_properties)) {
18297 visit_type_TransactionProperties(v, "properties", &obj->properties, &err);
18298 if (err) {
18299 goto out;
18300 }
18301 }
18302
18303out:
18304 error_propagate(errp, err);
18305}
18306
18307void visit_type_q_obj_x_blockdev_change_arg_members(Visitor *v, q_obj_x_blockdev_change_arg *obj, Error **errp)
18308{
18309 Error *err = NULL;
18310
18311 visit_type_str(v, "parent", &obj->parent, &err);
18312 if (err) {
18313 goto out;
18314 }
18315 if (visit_optional(v, "child", &obj->has_child)) {
18316 visit_type_str(v, "child", &obj->child, &err);
18317 if (err) {
18318 goto out;
18319 }
18320 }
18321 if (visit_optional(v, "node", &obj->has_node)) {
18322 visit_type_str(v, "node", &obj->node, &err);
18323 if (err) {
18324 goto out;
18325 }
18326 }
18327
18328out:
18329 error_propagate(errp, err);
18330}
18331
18332void visit_type_q_obj_x_blockdev_insert_medium_arg_members(Visitor *v, q_obj_x_blockdev_insert_medium_arg *obj, Error **errp)
18333{
18334 Error *err = NULL;
18335
18336 if (visit_optional(v, "device", &obj->has_device)) {
18337 visit_type_str(v, "device", &obj->device, &err);
18338 if (err) {
18339 goto out;
18340 }
18341 }
18342 if (visit_optional(v, "id", &obj->has_id)) {
18343 visit_type_str(v, "id", &obj->id, &err);
18344 if (err) {
18345 goto out;
18346 }
18347 }
18348 visit_type_str(v, "node-name", &obj->node_name, &err);
18349 if (err) {
18350 goto out;
18351 }
18352
18353out:
18354 error_propagate(errp, err);
18355}
18356
18357void visit_type_q_obj_x_blockdev_remove_medium_arg_members(Visitor *v, q_obj_x_blockdev_remove_medium_arg *obj, Error **errp)
18358{
18359 Error *err = NULL;
18360
18361 if (visit_optional(v, "device", &obj->has_device)) {
18362 visit_type_str(v, "device", &obj->device, &err);
18363 if (err) {
18364 goto out;
18365 }
18366 }
18367 if (visit_optional(v, "id", &obj->has_id)) {
18368 visit_type_str(v, "id", &obj->id, &err);
18369 if (err) {
18370 goto out;
18371 }
18372 }
18373
18374out:
18375 error_propagate(errp, err);
18376}
18377
18378void visit_type_q_obj_xen_load_devices_state_arg_members(Visitor *v, q_obj_xen_load_devices_state_arg *obj, Error **errp)
18379{
18380 Error *err = NULL;
18381
18382 visit_type_str(v, "filename", &obj->filename, &err);
18383 if (err) {
18384 goto out;
18385 }
18386
18387out:
18388 error_propagate(errp, err);
18389}
18390
18391void visit_type_q_obj_xen_save_devices_state_arg_members(Visitor *v, q_obj_xen_save_devices_state_arg *obj, Error **errp)
18392{
18393 Error *err = NULL;
18394
18395 visit_type_str(v, "filename", &obj->filename, &err);
18396 if (err) {
18397 goto out;
18398 }
18399
18400out:
18401 error_propagate(errp, err);
18402}
18403
18404void visit_type_q_obj_xen_set_global_dirty_log_arg_members(Visitor *v, q_obj_xen_set_global_dirty_log_arg *obj, Error **errp)
18405{
18406 Error *err = NULL;
18407
18408 visit_type_bool(v, "enable", &obj->enable, &err);
18409 if (err) {
18410 goto out;
18411 }
18412
18413out:
18414 error_propagate(errp, err);
18415}
18416
18417void visit_type_q_obj_xen_set_replication_arg_members(Visitor *v, q_obj_xen_set_replication_arg *obj, Error **errp)
18418{
18419 Error *err = NULL;
18420
18421 visit_type_bool(v, "enable", &obj->enable, &err);
18422 if (err) {
18423 goto out;
18424 }
18425 visit_type_bool(v, "primary", &obj->primary, &err);
18426 if (err) {
18427 goto out;
18428 }
18429 if (visit_optional(v, "failover", &obj->has_failover)) {
18430 visit_type_bool(v, "failover", &obj->failover, &err);
18431 if (err) {
18432 goto out;
18433 }
18434 }
18435
18436out:
18437 error_propagate(errp, err);
18438}
18439
18440void visit_type_sizeList(Visitor *v, const char *name, sizeList **obj, Error **errp)
18441{
18442 Error *err = NULL;
18443 sizeList *tail;
18444 size_t size = sizeof(**obj);
18445
18446 visit_start_list(v, name, (GenericList **)obj, size, &err);
18447 if (err) {
18448 goto out;
18449 }
18450
18451 for (tail = *obj; tail;
18452 tail = (sizeList *)visit_next_list(v, (GenericList *)tail, size)) {
18453 visit_type_size(v, NULL, &tail->value, &err);
18454 if (err) {
18455 break;
18456 }
18457 }
18458
18459 if (!err) {
18460 visit_check_list(v, &err);
18461 }
18462 visit_end_list(v, (void **)obj);
18463 if (err && visit_is_input(v)) {
18464 qapi_free_sizeList(*obj);
18465 *obj = NULL;
18466 }
18467out:
18468 error_propagate(errp, err);
18469}
18470
18471void visit_type_strList(Visitor *v, const char *name, strList **obj, Error **errp)
18472{
18473 Error *err = NULL;
18474 strList *tail;
18475 size_t size = sizeof(**obj);
18476
18477 visit_start_list(v, name, (GenericList **)obj, size, &err);
18478 if (err) {
18479 goto out;
18480 }
18481
18482 for (tail = *obj; tail;
18483 tail = (strList *)visit_next_list(v, (GenericList *)tail, size)) {
18484 visit_type_str(v, NULL, &tail->value, &err);
18485 if (err) {
18486 break;
18487 }
18488 }
18489
18490 if (!err) {
18491 visit_check_list(v, &err);
18492 }
18493 visit_end_list(v, (void **)obj);
18494 if (err && visit_is_input(v)) {
18495 qapi_free_strList(*obj);
18496 *obj = NULL;
18497 }
18498out:
18499 error_propagate(errp, err);
18500}
18501
18502void visit_type_uint16List(Visitor *v, const char *name, uint16List **obj, Error **errp)
18503{
18504 Error *err = NULL;
18505 uint16List *tail;
18506 size_t size = sizeof(**obj);
18507
18508 visit_start_list(v, name, (GenericList **)obj, size, &err);
18509 if (err) {
18510 goto out;
18511 }
18512
18513 for (tail = *obj; tail;
18514 tail = (uint16List *)visit_next_list(v, (GenericList *)tail, size)) {
18515 visit_type_uint16(v, NULL, &tail->value, &err);
18516 if (err) {
18517 break;
18518 }
18519 }
18520
18521 if (!err) {
18522 visit_check_list(v, &err);
18523 }
18524 visit_end_list(v, (void **)obj);
18525 if (err && visit_is_input(v)) {
18526 qapi_free_uint16List(*obj);
18527 *obj = NULL;
18528 }
18529out:
18530 error_propagate(errp, err);
18531}
18532
18533void visit_type_uint32List(Visitor *v, const char *name, uint32List **obj, Error **errp)
18534{
18535 Error *err = NULL;
18536 uint32List *tail;
18537 size_t size = sizeof(**obj);
18538
18539 visit_start_list(v, name, (GenericList **)obj, size, &err);
18540 if (err) {
18541 goto out;
18542 }
18543
18544 for (tail = *obj; tail;
18545 tail = (uint32List *)visit_next_list(v, (GenericList *)tail, size)) {
18546 visit_type_uint32(v, NULL, &tail->value, &err);
18547 if (err) {
18548 break;
18549 }
18550 }
18551
18552 if (!err) {
18553 visit_check_list(v, &err);
18554 }
18555 visit_end_list(v, (void **)obj);
18556 if (err && visit_is_input(v)) {
18557 qapi_free_uint32List(*obj);
18558 *obj = NULL;
18559 }
18560out:
18561 error_propagate(errp, err);
18562}
18563
18564void visit_type_uint64List(Visitor *v, const char *name, uint64List **obj, Error **errp)
18565{
18566 Error *err = NULL;
18567 uint64List *tail;
18568 size_t size = sizeof(**obj);
18569
18570 visit_start_list(v, name, (GenericList **)obj, size, &err);
18571 if (err) {
18572 goto out;
18573 }
18574
18575 for (tail = *obj; tail;
18576 tail = (uint64List *)visit_next_list(v, (GenericList *)tail, size)) {
18577 visit_type_uint64(v, NULL, &tail->value, &err);
18578 if (err) {
18579 break;
18580 }
18581 }
18582
18583 if (!err) {
18584 visit_check_list(v, &err);
18585 }
18586 visit_end_list(v, (void **)obj);
18587 if (err && visit_is_input(v)) {
18588 qapi_free_uint64List(*obj);
18589 *obj = NULL;
18590 }
18591out:
18592 error_propagate(errp, err);
18593}
18594
18595void visit_type_uint8List(Visitor *v, const char *name, uint8List **obj, Error **errp)
18596{
18597 Error *err = NULL;
18598 uint8List *tail;
18599 size_t size = sizeof(**obj);
18600
18601 visit_start_list(v, name, (GenericList **)obj, size, &err);
18602 if (err) {
18603 goto out;
18604 }
18605
18606 for (tail = *obj; tail;
18607 tail = (uint8List *)visit_next_list(v, (GenericList *)tail, size)) {
18608 visit_type_uint8(v, NULL, &tail->value, &err);
18609 if (err) {
18610 break;
18611 }
18612 }
18613
18614 if (!err) {
18615 visit_check_list(v, &err);
18616 }
18617 visit_end_list(v, (void **)obj);
18618 if (err && visit_is_input(v)) {
18619 qapi_free_uint8List(*obj);
18620 *obj = NULL;
18621 }
18622out:
18623 error_propagate(errp, err);
18624}
18625